/// 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 <isl/val.h>

#include <isl/aff.h>

#include <isl/set.h>

#include <isl/space.h>

#include <isl/id.h>

#include <isl/map.h>

#include <isl/vec.h>

#include <isl/ilp.h>

#include <isl/union_set.h>

#include <isl/union_map.h>

#include <isl/flow.h>

#include <isl/schedule.h>

#include <isl/schedule_node.h>

#include <isl/ast_build.h>

#include <isl/constraint.h>

#include <isl/polynomial.h>

#include <isl/mat.h>

#include <isl/fixed_box.h>

#include <stdio.h>

#include <stdlib.h>

#include <functional>

#include <string>

namespace isl {

inline namespace noexceptions {

#define ISLPP_STRINGIZE_(X) #X

#define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)

#define ISLPP_ASSERT(test, message)                          \

  do {                                                       \

    if (test)                                                \

      break;                                                 \

    fputs("Assertion \"" #test "\" failed at " __FILE__      \

      ":" ISLPP_STRINGIZE(__LINE__) "\n  " message "\n",     \

      stderr);                                               \

    abort();                                                 \

  } while (
00
)

class boolean {

private:

  mutable bool checked = false;

  isl_bool val;

  friend boolean manage(isl_bool val);

  boolean(isl_bool val): val(val) {}

public:

  boolean()

      : val(isl_bool_error) {}

  ~boolean() {

    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");

  }

  /* implicit */ boolean(bool val)

      : val(val ? isl_bool_true : isl_bool_false) {}

  bool is_error() const { checked = true; return val == isl_bool_error; }

  bool is_false() const { checked = true; return val == isl_bool_false; }

  bool is_true() const { checked = true; return val == isl_bool_true; }

  operator bool() const {

    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked error state");

    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");

    return is_true();

  }

  boolean operator!() const {

    if (is_error())

      return *this;

    return !is_true();

  }

};

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 bool checked = false;

  isl_stat val;

  friend stat manage(isl_stat val);

public:

  constexpr stat(isl_stat val) : val(val) {}

  static stat ok() {

    return stat(isl_stat_ok);

  }

  static stat error() {

    return stat(isl_stat_error);

  }

  stat() : val(isl_stat_error) {}

  ~stat() {

    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");

  }

  isl_stat release() {

    checked = true;

    return val;

  }

  bool is_error() const {

    checked = true;

    return val == isl_stat_error;

  }

  bool is_ok() const {

    checked = true;

    return val == isl_stat_ok;

  }

};

inline stat manage(isl_stat val)

{

  return stat(val);

}

enum class dim {

  cst = isl_dim_cst,

  param = isl_dim_param,

  in = isl_dim_in,

  out = isl_dim_out,

  set = isl_dim_set,

  div = isl_dim_div,

  all = isl_dim_all

};

}

} // namespace isl

namespace isl {

inline namespace noexceptions {

// forward declarations

class aff;

class aff_list;

class ast_build;

class ast_expr;

class ast_expr_list;

class ast_node;

class ast_node_list;

class basic_map;

class basic_map_list;

class basic_set;

class basic_set_list;

class constraint;

class constraint_list;

class fixed_box;

class id;

class id_list;

class id_to_ast_expr;

class local_space;

class map;

class map_list;

class mat;

class multi_aff;

class multi_pw_aff;

class multi_union_pw_aff;

class multi_val;

class point;

class pw_aff;

class pw_aff_list;

class pw_multi_aff;

class pw_multi_aff_list;

class pw_qpolynomial;

class pw_qpolynomial_fold_list;

class pw_qpolynomial_list;

class qpolynomial;

class schedule;

class schedule_constraints;

class schedule_node;

class set;

class set_list;

class space;

class term;

class union_access_info;

class union_flow;

class union_map;

class union_map_list;

class union_pw_aff;

class union_pw_aff_list;

class union_pw_multi_aff;

class union_pw_multi_aff_list;

class union_pw_qpolynomial;

class union_set;

class union_set_list;

class val;

class val_list;

class vec;

// declarations for isl::aff

inline aff manage(__isl_take isl_aff *ptr);

inline aff manage_copy(__isl_keep isl_aff *ptr);

class aff {

  friend inline aff manage(__isl_take isl_aff *ptr);

  friend inline aff manage_copy(__isl_keep isl_aff *ptr);

  isl_aff *ptr = nullptr;

  inline explicit aff(__isl_take isl_aff *ptr);

public:

  inline /* implicit */ aff();

  inline /* implicit */ aff(const aff &obj);

  inline /* implicit */ aff(std::nullptr_t);

  inline explicit aff(local_space ls);

  inline explicit aff(local_space ls, val val);

  inline explicit aff(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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  inline aff add(aff aff2) const;

  inline aff add_coefficient_si(isl::dim type, int pos, int v) const;

  inline aff add_coefficient_val(isl::dim type, int pos, val v) const;

  inline aff add_constant_num_si(int v) const;

  inline aff add_constant_si(int v) const;

  inline aff add_constant_val(val v) const;

  inline aff add_dims(isl::dim type, unsigned int n) const;

  inline aff align_params(space model) const;

  inline aff ceil() const;

  inline int coefficient_sgn(isl::dim type, int pos) const;

  inline int dim(isl::dim type) const;

  inline aff div(aff aff2) const;

  inline aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set eq_basic_set(aff aff2) const;

  inline set eq_set(aff aff2) const;

  inline val eval(point pnt) const;

  inline int find_dim_by_name(isl::dim type, const std::string &name) const;

  inline aff floor() const;

  inline aff from_range() const;

  inline basic_set ge_basic_set(aff aff2) const;

  inline set ge_set(aff aff2) const;

  inline val get_coefficient_val(isl::dim type, int pos) const;

  inline val get_constant_val() const;

  inline val get_denominator_val() const;

  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;

  inline aff get_div(int pos) const;

  inline local_space get_domain_local_space() const;

  inline space get_domain_space() const;

  inline uint32_t get_hash() const;

  inline local_space get_local_space() const;

  inline space get_space() const;

  inline aff gist(set context) const;

  inline aff gist_params(set context) const;

  inline basic_set gt_basic_set(aff aff2) const;

  inline set gt_set(aff aff2) const;

  inline aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline boolean is_cst() const;

  inline boolean is_nan() const;

  inline basic_set le_basic_set(aff aff2) const;

  inline set le_set(aff aff2) const;

  inline basic_set lt_basic_set(aff aff2) const;

  inline set lt_set(aff aff2) const;

  inline aff mod(val mod) const;

  inline aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;

  inline aff mul(aff aff2) const;

  static inline aff nan_on_domain(local_space ls);

  inline set ne_set(aff aff2) const;

  inline aff neg() const;

  inline basic_set neg_basic_set() const;

  static inline aff param_on_domain_space_id(space space, id id);

  inline boolean plain_is_equal(const aff &aff2) const;

  inline boolean plain_is_zero() const;

  inline aff project_domain_on_params() const;

  inline aff pullback(multi_aff ma) const;

  inline aff pullback_aff(aff aff2) const;

  inline aff scale(val v) const;

  inline aff scale_down(val v) const;

  inline aff scale_down_ui(unsigned int f) const;

  inline aff set_coefficient_si(isl::dim type, int pos, int v) const;

  inline aff set_coefficient_val(isl::dim type, int pos, val v) const;

  inline aff set_constant_si(int v) const;

  inline aff set_constant_val(val v) const;

  inline aff set_dim_id(isl::dim type, unsigned int pos, id id) const;

  inline aff set_tuple_id(isl::dim type, id id) const;

  inline aff sub(aff aff2) const;

  static inline aff var_on_domain(local_space ls, isl::dim type, unsigned int pos);

  inline basic_set zero_basic_set() const;

};

// 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);

  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 /* implicit */ aff_list(std::nullptr_t);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline aff_list add(aff el) const;

  static inline aff_list alloc(ctx ctx, int n);

  inline aff_list concat(aff_list list2) const;

  inline aff_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(aff)> &fn) const;

  static inline aff_list from_aff(aff el);

  inline aff get_aff(int index) const;

  inline aff get_at(int index) const;

  inline aff_list insert(unsigned int pos, aff el) const;

  inline int n_aff() const;

  inline aff_list reverse() const;

  inline aff_list set_aff(int index, aff el) const;

  inline int size() const;

  inline aff_list swap(unsigned int pos1, unsigned int pos2) 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);

  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 /* implicit */ ast_build(std::nullptr_t);

  inline explicit ast_build(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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline ast_expr access_from(pw_multi_aff pma) const;

  inline ast_expr access_from(multi_pw_aff mpa) const;

  inline ast_node ast_from_schedule(union_map schedule) const;

  inline ast_expr call_from(pw_multi_aff pma) const;

  inline ast_expr call_from(multi_pw_aff mpa) const;

  inline ast_expr expr_from(set set) const;

  inline ast_expr expr_from(pw_aff pa) const;

  static inline ast_build from_context(set set);

  inline union_map get_schedule() const;

  inline space get_schedule_space() const;

  inline ast_node node_from_schedule(schedule schedule) const;

  inline ast_node node_from_schedule_map(union_map schedule) const;

  inline ast_build restrict(set set) 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);

  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 /* implicit */ ast_expr(std::nullptr_t);

  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;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  inline ast_expr access(ast_expr_list indices) const;

  inline ast_expr add(ast_expr expr2) const;

  inline ast_expr address_of() const;

  inline ast_expr call(ast_expr_list arguments) const;

  inline ast_expr div(ast_expr expr2) const;

  inline ast_expr eq(ast_expr expr2) const;

  static inline ast_expr from_id(id id);

  static inline ast_expr from_val(val v);

  inline ast_expr ge(ast_expr expr2) const;

  inline id get_id() const;

  inline ast_expr get_op_arg(int pos) const;

  inline int get_op_n_arg() const;

  inline val get_val() const;

  inline ast_expr gt(ast_expr expr2) const;

  inline boolean is_equal(const ast_expr &expr2) const;

  inline ast_expr le(ast_expr expr2) const;

  inline ast_expr lt(ast_expr expr2) const;

  inline ast_expr mul(ast_expr expr2) const;

  inline ast_expr neg() const;

  inline ast_expr pdiv_q(ast_expr expr2) const;

  inline ast_expr pdiv_r(ast_expr expr2) const;

  inline ast_expr set_op_arg(int pos, ast_expr arg) const;

  inline ast_expr sub(ast_expr expr2) const;

  inline ast_expr substitute_ids(id_to_ast_expr id2expr) const;

  inline std::string to_C_str() const;

};

// declarations for isl::ast_expr_list

inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);

inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);

class ast_expr_list {

  friend inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);

  friend inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);

  isl_ast_expr_list *ptr = nullptr;

  inline explicit ast_expr_list(__isl_take isl_ast_expr_list *ptr);

public:

  inline /* implicit */ ast_expr_list();

  inline /* implicit */ ast_expr_list(const ast_expr_list &obj);

  inline /* implicit */ ast_expr_list(std::nullptr_t);

  inline ast_expr_list &operator=(ast_expr_list obj);

  inline ~ast_expr_list();

  inline __isl_give isl_ast_expr_list *copy() const &;

  inline __isl_give isl_ast_expr_list *copy() && = delete;

  inline __isl_keep isl_ast_expr_list *get() const;

  inline __isl_give isl_ast_expr_list *release();

  inline bool is_null() const;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline ast_expr_list add(ast_expr el) const;

  static inline ast_expr_list alloc(ctx ctx, int n);

  inline ast_expr_list concat(ast_expr_list list2) const;

  inline ast_expr_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(ast_expr)> &fn) const;

  static inline ast_expr_list from_ast_expr(ast_expr el);

  inline ast_expr get_ast_expr(int index) const;

  inline ast_expr get_at(int index) const;

  inline ast_expr_list insert(unsigned int pos, ast_expr el) const;

  inline int n_ast_expr() const;

  inline ast_expr_list reverse() const;

  inline ast_expr_list set_ast_expr(int index, ast_expr el) const;

  inline int size() const;

  inline ast_expr_list swap(unsigned int pos1, unsigned int pos2) const;

};

// declarations for isl::ast_node

inline ast_node manage(__isl_take isl_ast_node *ptr);

inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);

class ast_node {

  friend inline ast_node manage(__isl_take isl_ast_node *ptr);

  friend inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);

  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 /* implicit */ ast_node(std::nullptr_t);

  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;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  static inline ast_node alloc_user(ast_expr expr);

  inline ast_node_list block_get_children() const;

  inline ast_node for_get_body() const;

  inline ast_expr for_get_cond() const;

  inline ast_expr for_get_inc() const;

  inline ast_expr for_get_init() const;

  inline ast_expr for_get_iterator() const;

  inline boolean for_is_degenerate() const;

  inline id get_annotation() const;

  inline ast_expr if_get_cond() const;

  inline ast_node if_get_else() const;

  inline ast_node if_get_then() const;

  inline boolean if_has_else() const;

  inline id mark_get_id() const;

  inline ast_node mark_get_node() const;

  inline ast_node set_annotation(id annotation) const;

  inline std::string to_C_str() const;

  inline ast_expr user_get_expr() 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);

  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 /* implicit */ ast_node_list(std::nullptr_t);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline ast_node_list add(ast_node el) const;

  static inline ast_node_list alloc(ctx ctx, int n);

  inline ast_node_list concat(ast_node_list list2) const;

  inline ast_node_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(ast_node)> &fn) const;

  static inline ast_node_list from_ast_node(ast_node el);

  inline ast_node get_ast_node(int index) const;

  inline ast_node get_at(int index) const;

  inline ast_node_list insert(unsigned int pos, ast_node el) const;

  inline int n_ast_node() const;

  inline ast_node_list reverse() const;

  inline ast_node_list set_ast_node(int index, ast_node el) const;

  inline int size() const;

  inline ast_node_list swap(unsigned int pos1, unsigned int pos2) 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);

  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 /* implicit */ basic_map(std::nullptr_t);

  inline explicit basic_map(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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  inline basic_map add_constraint(constraint constraint) const;

  inline basic_map add_dims(isl::dim type, unsigned int n) const;

  inline basic_map affine_hull() const;

  inline basic_map align_params(space model) const;

  inline basic_map apply_domain(basic_map bmap2) const;

  inline basic_map apply_range(basic_map bmap2) const;

  inline boolean can_curry() const;

  inline boolean can_uncurry() const;

  inline boolean can_zip() const;

  inline basic_map curry() const;

  inline basic_set deltas() const;

  inline basic_map deltas_map() const;

  inline basic_map detect_equalities() const;

  inline unsigned int dim(isl::dim type) const;

  inline basic_set domain() const;

  inline basic_map domain_map() const;

  inline basic_map domain_product(basic_map bmap2) const;

  inline basic_map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_map drop_unused_params() const;

  inline basic_map eliminate(isl::dim type, unsigned int first, unsigned int n) const;

  static inline basic_map empty(space space);

  static inline basic_map equal(space dim, unsigned int n_equal);

  inline mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;

  inline basic_map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;

  inline int find_dim_by_name(isl::dim type, const std::string &name) const;

  inline basic_map fix_si(isl::dim type, unsigned int pos, int value) const;

  inline basic_map fix_val(isl::dim type, unsigned int pos, val v) const;

  inline basic_map flat_product(basic_map bmap2) const;

  inline basic_map flat_range_product(basic_map bmap2) const;

  inline basic_map flatten() const;

  inline basic_map flatten_domain() const;

  inline basic_map flatten_range() const;

  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;

  static inline basic_map from_aff(aff aff);

  static inline basic_map from_aff_list(space domain_space, aff_list list);

  static inline basic_map from_constraint(constraint constraint);

  static inline basic_map from_domain(basic_set bset);

  static inline basic_map from_domain_and_range(basic_set domain, basic_set range);

  static inline basic_map from_multi_aff(multi_aff maff);

  static inline basic_map from_qpolynomial(qpolynomial qp);

  static inline basic_map from_range(basic_set bset);

  inline constraint_list get_constraint_list() const;

  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;

  inline aff get_div(int pos) const;

  inline local_space get_local_space() const;

  inline space get_space() const;

  inline std::string get_tuple_name(isl::dim type) const;

  inline basic_map gist(basic_map context) const;

  inline basic_map gist_domain(basic_set context) const;

  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;

  static inline basic_map identity(space dim);

  inline boolean image_is_bounded() const;

  inline mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;

  inline basic_map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;

  inline basic_map intersect(basic_map bmap2) const;

  inline basic_map intersect_domain(basic_set bset) const;

  inline basic_map intersect_range(basic_set bset) const;

  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline boolean is_disjoint(const basic_map &bmap2) const;

  inline boolean is_empty() const;

  inline boolean is_equal(const basic_map &bmap2) const;

  inline boolean is_rational() const;

  inline boolean is_single_valued() const;

  inline boolean is_strict_subset(const basic_map &bmap2) const;

  inline boolean is_subset(const basic_map &bmap2) const;

  inline boolean is_universe() const;

  static inline basic_map less_at(space dim, unsigned int pos);

  inline map lexmax() const;

  inline map lexmin() const;

  inline pw_multi_aff lexmin_pw_multi_aff() const;

  inline basic_map lower_bound_si(isl::dim type, unsigned int pos, int value) const;

  static inline basic_map more_at(space dim, unsigned int pos);

  inline basic_map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;

  inline int n_constraint() const;

  static inline basic_map nat_universe(space dim);

  inline basic_map neg() const;

  inline basic_map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;

  inline basic_map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;

  inline val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;

  inline boolean plain_is_empty() const;

  inline boolean plain_is_universe() const;

  inline basic_map preimage_domain_multi_aff(multi_aff ma) const;

  inline basic_map preimage_range_multi_aff(multi_aff ma) const;

  inline basic_map product(basic_map bmap2) const;

  inline basic_map project_out(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set range() const;

  inline basic_map range_map() const;

  inline basic_map range_product(basic_map bmap2) const;

  inline basic_map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_map remove_divs() const;

  inline basic_map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_map remove_redundancies() const;

  inline basic_map reverse() const;

  inline basic_map sample() const;

  inline basic_map set_tuple_id(isl::dim type, id id) const;

  inline basic_map set_tuple_name(isl::dim type, const std::string &s) const;

  inline basic_map sum(basic_map bmap2) const;

  inline basic_map uncurry() const;

  inline map unite(basic_map bmap2) const;

  static inline basic_map universe(space space);

  inline basic_map upper_bound_si(isl::dim type, unsigned int pos, int value) const;

  inline basic_set wrap() const;

  inline basic_map zip() const;

};

// declarations for isl::basic_map_list

inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);

inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);

class basic_map_list {

  friend inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);

  friend inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);

  isl_basic_map_list *ptr = nullptr;

  inline explicit basic_map_list(__isl_take isl_basic_map_list *ptr);

public:

  inline /* implicit */ basic_map_list();

  inline /* implicit */ basic_map_list(const basic_map_list &obj);

  inline /* implicit */ basic_map_list(std::nullptr_t);

  inline basic_map_list &operator=(basic_map_list obj);

  inline ~basic_map_list();

  inline __isl_give isl_basic_map_list *copy() const &;

  inline __isl_give isl_basic_map_list *copy() && = delete;

  inline __isl_keep isl_basic_map_list *get() const;

  inline __isl_give isl_basic_map_list *release();

  inline bool is_null() const;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline basic_map_list add(basic_map el) const;

  static inline basic_map_list alloc(ctx ctx, int n);

  inline basic_map_list concat(basic_map_list list2) const;

  inline basic_map_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(basic_map)> &fn) const;

  static inline basic_map_list from_basic_map(basic_map el);

  inline basic_map get_at(int index) const;

  inline basic_map get_basic_map(int index) const;

  inline basic_map_list insert(unsigned int pos, basic_map el) const;

  inline int n_basic_map() const;

  inline basic_map_list reverse() const;

  inline basic_map_list set_basic_map(int index, basic_map el) const;

  inline int size() const;

  inline basic_map_list swap(unsigned int pos1, unsigned int pos2) 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);

  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(std::nullptr_t);

  inline explicit basic_set(ctx ctx, const std::string &str);

  inline /* implicit */ basic_set(point pnt);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  inline basic_set affine_hull() const;

  inline basic_set align_params(space model) const;

  inline basic_set apply(basic_map bmap) const;

  static inline basic_set box_from_points(point pnt1, point pnt2);

  inline basic_set coefficients() const;

  inline basic_set detect_equalities() const;

  inline unsigned int dim(isl::dim type) const;

  inline val dim_max_val(int pos) const;

  inline basic_set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set drop_unused_params() const;

  inline basic_set eliminate(isl::dim type, unsigned int first, unsigned int n) const;

  static inline basic_set empty(space space);

  inline mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;

  inline basic_set fix_si(isl::dim type, unsigned int pos, int value) const;

  inline basic_set fix_val(isl::dim type, unsigned int pos, val v) const;

  inline basic_set flat_product(basic_set bset2) const;

  inline basic_set flatten() const;

  inline stat foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<stat(constraint, constraint, basic_set)> &fn) const;

  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;

  static inline basic_set from_constraint(constraint constraint);

  static inline basic_set from_multi_aff(multi_aff ma);

  inline basic_set from_params() const;

  inline constraint_list get_constraint_list() const;

  inline id get_dim_id(isl::dim type, unsigned int pos) const;

  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;

  inline aff get_div(int pos) const;

  inline local_space get_local_space() const;

  inline space get_space() const;

  inline std::string get_tuple_name() const;

  inline basic_set gist(basic_set context) const;

  inline mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;

  inline basic_set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;

  inline basic_set intersect(basic_set bset2) const;

  inline basic_set intersect_params(basic_set bset2) const;

  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline boolean is_bounded() const;

  inline boolean is_disjoint(const basic_set &bset2) const;

  inline boolean is_empty() const;

  inline boolean is_equal(const basic_set &bset2) const;

  inline int is_rational() const;

  inline boolean is_subset(const basic_set &bset2) const;

  inline boolean is_universe() const;

  inline boolean is_wrapping() const;

  inline set lexmax() const;

  inline set lexmin() const;

  inline basic_set lower_bound_val(isl::dim type, unsigned int pos, val value) const;

  inline val max_val(const aff &obj) const;

  inline basic_set move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;

  inline int n_constraint() const;

  inline unsigned int n_dim() const;

  static inline basic_set nat_universe(space dim);

  inline basic_set neg() const;

  inline basic_set params() const;

  inline boolean plain_is_empty() const;

  inline boolean plain_is_equal(const basic_set &bset2) const;

  inline boolean plain_is_universe() const;

  static inline basic_set positive_orthant(space space);

  inline basic_set preimage_multi_aff(multi_aff ma) const;

  inline basic_set project_out(isl::dim type, unsigned int first, unsigned int n) const;

  inline mat reduced_basis() const;

  inline basic_set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set remove_divs() const;

  inline basic_set remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline basic_set remove_redundancies() const;

  inline basic_set remove_unknown_divs() const;

  inline basic_set sample() const;

  inline point sample_point() const;

  inline basic_set set_tuple_id(id id) const;

  inline basic_set set_tuple_name(const std::string &s) const;

  inline basic_set solutions() const;

  inline set unite(basic_set bset2) const;

  static inline basic_set universe(space space);

  inline basic_map unwrap() const;

  inline basic_set upper_bound_val(isl::dim type, unsigned int pos, val value) const;

};

// declarations for isl::basic_set_list

inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);

inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);

class basic_set_list {

  friend inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);

  friend inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);

  isl_basic_set_list *ptr = nullptr;

  inline explicit basic_set_list(__isl_take isl_basic_set_list *ptr);

public:

  inline /* implicit */ basic_set_list();

  inline /* implicit */ basic_set_list(const basic_set_list &obj);

  inline /* implicit */ basic_set_list(std::nullptr_t);

  inline basic_set_list &operator=(basic_set_list obj);

  inline ~basic_set_list();

  inline __isl_give isl_basic_set_list *copy() const &;

  inline __isl_give isl_basic_set_list *copy() && = delete;

  inline __isl_keep isl_basic_set_list *get() const;

  inline __isl_give isl_basic_set_list *release();

  inline bool is_null() const;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline basic_set_list add(basic_set el) const;

  static inline basic_set_list alloc(ctx ctx, int n);

  inline basic_set_list coefficients() const;

  inline basic_set_list concat(basic_set_list list2) const;

  inline basic_set_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(basic_set)> &fn) const;

  static inline basic_set_list from_basic_set(basic_set el);

  inline basic_set get_at(int index) const;

  inline basic_set get_basic_set(int index) const;

  inline basic_set_list insert(unsigned int pos, basic_set el) const;

  inline int n_basic_set() const;

  inline basic_set_list reverse() const;

  inline basic_set_list set_basic_set(int index, basic_set el) const;

  inline int size() const;

  inline basic_set_list swap(unsigned int pos1, unsigned int pos2) const;

};

// declarations for isl::constraint

inline constraint manage(__isl_take isl_constraint *ptr);

inline constraint manage_copy(__isl_keep isl_constraint *ptr);

class constraint {

  friend inline constraint manage(__isl_take isl_constraint *ptr);

  friend inline constraint manage_copy(__isl_keep isl_constraint *ptr);

  isl_constraint *ptr = nullptr;

  inline explicit constraint(__isl_take isl_constraint *ptr);

public:

  inline /* implicit */ constraint();

  inline /* implicit */ constraint(const constraint &obj);

  inline /* implicit */ constraint(std::nullptr_t);

  inline constraint &operator=(constraint obj);

  inline ~constraint();

  inline __isl_give isl_constraint *copy() const &;

  inline __isl_give isl_constraint *copy() && = delete;

  inline __isl_keep isl_constraint *get() const;

  inline __isl_give isl_constraint *release();

  inline bool is_null() const;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  static inline constraint alloc_equality(local_space ls);

  static inline constraint alloc_inequality(local_space ls);

  inline int cmp_last_non_zero(const constraint &c2) const;

  inline aff get_aff() const;

  inline aff get_bound(isl::dim type, int pos) const;

  inline val get_coefficient_val(isl::dim type, int pos) const;

  inline val get_constant_val() const;

  inline std::string get_dim_name(isl::dim type, unsigned int pos) const;

  inline aff get_div(int pos) const;

  inline local_space get_local_space() const;

  inline space get_space() const;

  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;

  inline int is_div_constraint() const;

  inline boolean is_lower_bound(isl::dim type, unsigned int pos) const;

  inline boolean is_upper_bound(isl::dim type, unsigned int pos) const;

  inline int plain_cmp(const constraint &c2) const;

  inline constraint set_coefficient_si(isl::dim type, int pos, int v) const;

  inline constraint set_coefficient_val(isl::dim type, int pos, val v) const;

  inline constraint set_constant_si(int v) const;

  inline constraint set_constant_val(val v) const;

};

// declarations for isl::constraint_list

inline constraint_list manage(__isl_take isl_constraint_list *ptr);

inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);

class constraint_list {

  friend inline constraint_list manage(__isl_take isl_constraint_list *ptr);

  friend inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);

  isl_constraint_list *ptr = nullptr;

  inline explicit constraint_list(__isl_take isl_constraint_list *ptr);

public:

  inline /* implicit */ constraint_list();

  inline /* implicit */ constraint_list(const constraint_list &obj);

  inline /* implicit */ constraint_list(std::nullptr_t);

  inline constraint_list &operator=(constraint_list obj);

  inline ~constraint_list();

  inline __isl_give isl_constraint_list *copy() const &;

  inline __isl_give isl_constraint_list *copy() && = delete;

  inline __isl_keep isl_constraint_list *get() const;

  inline __isl_give isl_constraint_list *release();

  inline bool is_null() const;

  inline explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline constraint_list add(constraint el) const;

  static inline constraint_list alloc(ctx ctx, int n);

  inline constraint_list concat(constraint_list list2) const;

  inline constraint_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(constraint)> &fn) const;

  static inline constraint_list from_constraint(constraint el);

  inline constraint get_at(int index) const;

  inline constraint get_constraint(int index) const;

  inline constraint_list insert(unsigned int pos, constraint el) const;

  inline int n_constraint() const;

  inline constraint_list reverse() const;

  inline constraint_list set_constraint(int index, constraint el) const;

  inline int size() const;

  inline constraint_list swap(unsigned int pos1, unsigned int pos2) 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);

  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 /* implicit */ fixed_box(std::nullptr_t);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline multi_aff get_offset() const;

  inline multi_val get_size() const;

  inline space get_space() const;

  inline boolean is_valid() const;

};

// declarations for isl::id

inline id manage(__isl_take isl_id *ptr);

inline id manage_copy(__isl_keep isl_id *ptr);

class id {

  friend inline id manage(__isl_take isl_id *ptr);

  friend inline id manage_copy(__isl_keep isl_id *ptr);

  isl_id *ptr = nullptr;

  inline explicit id(__isl_take isl_id *ptr);

public:

  inline /* implicit */ id();

  inline /* implicit */ id(const id &obj);

  inline /* implicit */ id(std::nullptr_t);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline std::string to_str() const;

  inline void dump() const;

  static inline id alloc(ctx ctx, const std::string &name, void * user);

  inline uint32_t get_hash() const;

  inline std::string get_name() const;

  inline void * get_user() const;

};

// declarations for isl::id_list

inline id_list manage(__isl_take isl_id_list *ptr);

inline id_list manage_copy(__isl_keep isl_id_list *ptr);

class id_list {

  friend inline id_list manage(__isl_take isl_id_list *ptr);

  friend inline id_list manage_copy(__isl_keep isl_id_list *ptr);

  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 /* implicit */ id_list(std::nullptr_t);

  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 explicit operator bool() const;

  inline ctx get_ctx() const;

  inline void dump() const;

  inline id_list add(id el) const;

  static inline id_list alloc(ctx ctx, int n);

  inline id_list concat(id_list list2) const;

  inline id_list drop(unsigned int first, unsigned int n) const;

  inline stat foreach(const std::function<stat(id)> &fn) const;

  static inline id_list from_id(id el);

  inline id get_at(int index) const;

  inline id get_id(int index) const;

  inline id_list insert(unsigned int pos, id el) const;

  inline int n_id() const;

  inline id_list reverse() const;

  inline id_list set_id(int index, id el) const;

  inline int size() const;

  inline id_list swap(unsigned int pos1, unsigned int pos2) const;

};

// declarations for isl::id_to_ast_expr

inline id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);

inline id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);

class id_to_ast_expr {