analysis.h

#pragma once
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <iterator>
#include <new>
#include <string>
#include <type_traits>
#include <utility>
 
namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"
 
#ifndef CXXBRIDGE1_PANIC
#define CXXBRIDGE1_PANIC
template <typename Exception>
void panic [[noreturn]] (const char *msg);
#endif // CXXBRIDGE1_PANIC
 
struct unsafe_bitcopy_t;
 
namespace {
template <typename T>
class impl;
} // namespace
 
template <typename T>
::std::size_t size_of();
template <typename T>
::std::size_t align_of();
 
#ifndef CXXBRIDGE1_RUST_STRING
#define CXXBRIDGE1_RUST_STRING
class String final {
public:
  String() noexcept;
  String(const String &) noexcept;
  String(String &&) noexcept;
  ~String() noexcept;
 
  String(const std::string &);
  String(const char *);
  String(const char *, std::size_t);
 
  String &operator=(const String &) noexcept;
  String &operator=(String &&) noexcept;
 
  explicit operator std::string() const;
 
  const char *data() const noexcept;
  std::size_t size() const noexcept;
  std::size_t length() const noexcept;
 
  const char *c_str() noexcept;
 
  using iterator = char *;
  iterator begin() noexcept;
  iterator end() noexcept;
 
  using const_iterator = const char *;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
 
  bool operator==(const String &) const noexcept;
  bool operator!=(const String &) const noexcept;
  bool operator<(const String &) const noexcept;
  bool operator<=(const String &) const noexcept;
  bool operator>(const String &) const noexcept;
  bool operator>=(const String &) const noexcept;
 
  void swap(String &) noexcept;
 
  String(unsafe_bitcopy_t, const String &) noexcept;
 
private:
  friend void swap(String &lhs, String &rhs) noexcept { lhs.swap(rhs); }
 
  std::array<std::uintptr_t, 3> repr;
};
#endif // CXXBRIDGE1_RUST_STRING
 
#ifndef CXXBRIDGE1_RUST_STR
#define CXXBRIDGE1_RUST_STR
class Str final {
public:
  Str() noexcept;
  Str(const String &) noexcept;
  Str(const std::string &);
  Str(const char *);
  Str(const char *, std::size_t);
 
  Str &operator=(const Str &) noexcept = default;
 
  explicit operator std::string() const;
 
  const char *data() const noexcept;
  std::size_t size() const noexcept;
  std::size_t length() const noexcept;
 
  Str(const Str &) noexcept = default;
  ~Str() noexcept = default;
 
  using iterator = const char *;
  using const_iterator = const char *;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
 
  bool operator==(const Str &) const noexcept;
  bool operator!=(const Str &) const noexcept;
  bool operator<(const Str &) const noexcept;
  bool operator<=(const Str &) const noexcept;
  bool operator>(const Str &) const noexcept;
  bool operator>=(const Str &) const noexcept;
 
  void swap(Str &) noexcept;
 
private:
  class uninit;
  Str(uninit) noexcept;
  friend impl<Str>;
 
  std::array<std::uintptr_t, 2> repr;
};
#endif // CXXBRIDGE1_RUST_STR
 
#ifndef CXXBRIDGE1_RUST_SLICE
#define CXXBRIDGE1_RUST_SLICE
namespace detail {
template <bool>
struct copy_assignable_if {};
 
template <>
struct copy_assignable_if<false> {
  copy_assignable_if() noexcept = default;
  copy_assignable_if(const copy_assignable_if &) noexcept = default;
  copy_assignable_if &operator=(const copy_assignable_if &) noexcept = delete;
  copy_assignable_if &operator=(copy_assignable_if &&) noexcept = default;
};
} // namespace detail
 
template <typename T>
class Slice final
    : private detail::copy_assignable_if<std::is_const<T>::value> {
public:
  using value_type = T;
 
  Slice() noexcept;
  Slice(T *, std::size_t count) noexcept;
 
  Slice &operator=(const Slice<T> &) noexcept = default;
  Slice &operator=(Slice<T> &&) noexcept = default;
 
  T *data() const noexcept;
  std::size_t size() const noexcept;
  std::size_t length() const noexcept;
  bool empty() const noexcept;
 
  T &operator[](std::size_t n) const noexcept;
  T &at(std::size_t n) const;
  T &front() const noexcept;
  T &back() const noexcept;
 
  Slice(const Slice<T> &) noexcept = default;
  ~Slice() noexcept = default;
 
  class iterator;
  iterator begin() const noexcept;
  iterator end() const noexcept;
 
  void swap(Slice &) noexcept;
 
private:
  class uninit;
  Slice(uninit) noexcept;
  friend impl<Slice>;
  friend void sliceInit(void *, const void *, std::size_t) noexcept;
  friend void *slicePtr(const void *) noexcept;
  friend std::size_t sliceLen(const void *) noexcept;
 
  std::array<std::uintptr_t, 2> repr;
};
 
template <typename T>
class Slice<T>::iterator final {
public:
  using iterator_category = std::random_access_iterator_tag;
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = typename std::add_pointer<T>::type;
  using reference = typename std::add_lvalue_reference<T>::type;
 
  reference operator*() const noexcept;
  pointer operator->() const noexcept;
  reference operator[](difference_type) const noexcept;
 
  iterator &operator++() noexcept;
  iterator operator++(int) noexcept;
  iterator &operator--() noexcept;
  iterator operator--(int) noexcept;
 
  iterator &operator+=(difference_type) noexcept;
  iterator &operator-=(difference_type) noexcept;
  iterator operator+(difference_type) const noexcept;
  iterator operator-(difference_type) const noexcept;
  difference_type operator-(const iterator &) const noexcept;
 
  bool operator==(const iterator &) const noexcept;
  bool operator!=(const iterator &) const noexcept;
  bool operator<(const iterator &) const noexcept;
  bool operator<=(const iterator &) const noexcept;
  bool operator>(const iterator &) const noexcept;
  bool operator>=(const iterator &) const noexcept;
 
private:
  friend class Slice;
  void *pos;
  std::size_t stride;
};
 
template <typename T>
Slice<T>::Slice() noexcept {
  sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
}
 
template <typename T>
Slice<T>::Slice(T *s, std::size_t count) noexcept {
  sliceInit(this, const_cast<typename std::remove_const<T>::type *>(s), count);
}
 
template <typename T>
T *Slice<T>::data() const noexcept {
  return reinterpret_cast<T *>(slicePtr(this));
}
 
template <typename T>
std::size_t Slice<T>::size() const noexcept {
  return sliceLen(this);
}
 
template <typename T>
std::size_t Slice<T>::length() const noexcept {
  return this->size();
}
 
template <typename T>
bool Slice<T>::empty() const noexcept {
  return this->size() == 0;
}
 
template <typename T>
T &Slice<T>::operator[](std::size_t n) const noexcept {
  assert(n < this->size());
  auto pos = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
  return *reinterpret_cast<T *>(pos);
}
 
template <typename T>
T &Slice<T>::at(std::size_t n) const {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Slice index out of range");
  }
  return (*this)[n];
}
 
template <typename T>
T &Slice<T>::front() const noexcept {
  assert(!this->empty());
  return (*this)[0];
}
 
template <typename T>
T &Slice<T>::back() const noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}
 
template <typename T>
typename Slice<T>::iterator::reference
Slice<T>::iterator::operator*() const noexcept {
  return *static_cast<T *>(this->pos);
}
 
template <typename T>
typename Slice<T>::iterator::pointer
Slice<T>::iterator::operator->() const noexcept {
  return static_cast<T *>(this->pos);
}
 
template <typename T>
typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto pos = static_cast<char *>(this->pos) + this->stride * n;
  return *reinterpret_cast<T *>(pos);
}
 
template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept {
  this->pos = static_cast<char *>(this->pos) + this->stride;
  return *this;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept {
  auto ret = iterator(*this);
  this->pos = static_cast<char *>(this->pos) + this->stride;
  return ret;
}
 
template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept {
  this->pos = static_cast<char *>(this->pos) - this->stride;
  return *this;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept {
  auto ret = iterator(*this);
  this->pos = static_cast<char *>(this->pos) - this->stride;
  return ret;
}
 
template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
    typename Slice<T>::iterator::difference_type n) noexcept {
  this->pos = static_cast<char *>(this->pos) + this->stride * n;
  return *this;
}
 
template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
    typename Slice<T>::iterator::difference_type n) noexcept {
  this->pos = static_cast<char *>(this->pos) - this->stride * n;
  return *this;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator+(
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto ret = iterator(*this);
  ret.pos = static_cast<char *>(this->pos) + this->stride * n;
  return ret;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator-(
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto ret = iterator(*this);
  ret.pos = static_cast<char *>(this->pos) - this->stride * n;
  return ret;
}
 
template <typename T>
typename Slice<T>::iterator::difference_type
Slice<T>::iterator::operator-(const iterator &other) const noexcept {
  auto diff = std::distance(static_cast<char *>(other.pos),
                            static_cast<char *>(this->pos));
  return diff / this->stride;
}
 
template <typename T>
bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
  return this->pos == other.pos;
}
 
template <typename T>
bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
  return this->pos != other.pos;
}
 
template <typename T>
bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
  return this->pos < other.pos;
}
 
template <typename T>
bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
  return this->pos <= other.pos;
}
 
template <typename T>
bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
  return this->pos > other.pos;
}
 
template <typename T>
bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
  return this->pos >= other.pos;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::begin() const noexcept {
  iterator it;
  it.pos = slicePtr(this);
  it.stride = size_of<T>();
  return it;
}
 
template <typename T>
typename Slice<T>::iterator Slice<T>::end() const noexcept {
  iterator it = this->begin();
  it.pos = static_cast<char *>(it.pos) + it.stride * this->size();
  return it;
}
 
template <typename T>
void Slice<T>::swap(Slice &rhs) noexcept {
  std::swap(*this, rhs);
}
#endif // CXXBRIDGE1_RUST_SLICE
 
#ifndef CXXBRIDGE1_RUST_BOX
#define CXXBRIDGE1_RUST_BOX
template <typename T>
class Box final {
public:
  using element_type = T;
  using const_pointer =
      typename std::add_pointer<typename std::add_const<T>::type>::type;
  using pointer = typename std::add_pointer<T>::type;
 
  Box() = delete;
  Box(Box &&) noexcept;
  ~Box() noexcept;
 
  explicit Box(const T &);
  explicit Box(T &&);
 
  Box &operator=(Box &&) noexcept;
 
  const T *operator->() const noexcept;
  const T &operator*() const noexcept;
  T *operator->() noexcept;
  T &operator*() noexcept;
 
  template <typename... Fields>
  static Box in_place(Fields &&...);
 
  void swap(Box &) noexcept;
 
  static Box from_raw(T *) noexcept;
 
  T *into_raw() noexcept;
 
  /* Deprecated */ using value_type = element_type;
 
private:
  class uninit;
  class allocation;
  Box(uninit) noexcept;
  void drop() noexcept;
 
  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
 
  T *ptr;
};
 
template <typename T>
class Box<T>::uninit {};
 
template <typename T>
class Box<T>::allocation {
  static T *alloc() noexcept;
  static void dealloc(T *) noexcept;
 
public:
  allocation() noexcept : ptr(alloc()) {}
  ~allocation() noexcept {
    if (this->ptr) {
      dealloc(this->ptr);
    }
  }
  T *ptr;
};
 
template <typename T>
Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
  other.ptr = nullptr;
}
 
template <typename T>
Box<T>::Box(const T &val) {
  allocation alloc;
  ::new (alloc.ptr) T(val);
  this->ptr = alloc.ptr;
  alloc.ptr = nullptr;
}
 
template <typename T>
Box<T>::Box(T &&val) {
  allocation alloc;
  ::new (alloc.ptr) T(std::move(val));
  this->ptr = alloc.ptr;
  alloc.ptr = nullptr;
}
 
template <typename T>
Box<T>::~Box() noexcept {
  if (this->ptr) {
    this->drop();
  }
}
 
template <typename T>
Box<T> &Box<T>::operator=(Box &&other) noexcept {
  if (this->ptr) {
    this->drop();
  }
  this->ptr = other.ptr;
  other.ptr = nullptr;
  return *this;
}
 
template <typename T>
const T *Box<T>::operator->() const noexcept {
  return this->ptr;
}
 
template <typename T>
const T &Box<T>::operator*() const noexcept {
  return *this->ptr;
}
 
template <typename T>
T *Box<T>::operator->() noexcept {
  return this->ptr;
}
 
template <typename T>
T &Box<T>::operator*() noexcept {
  return *this->ptr;
}
 
template <typename T>
template <typename... Fields>
Box<T> Box<T>::in_place(Fields &&... fields) {
  allocation alloc;
  auto ptr = alloc.ptr;
  ::new (ptr) T{std::forward<Fields>(fields)...};
  alloc.ptr = nullptr;
  return from_raw(ptr);
}
 
template <typename T>
void Box<T>::swap(Box &rhs) noexcept {
  using std::swap;
  swap(this->ptr, rhs.ptr);
}
 
template <typename T>
Box<T> Box<T>::from_raw(T *raw) noexcept {
  Box box = uninit{};
  box.ptr = raw;
  return box;
}
 
template <typename T>
T *Box<T>::into_raw() noexcept {
  T *raw = this->ptr;
  this->ptr = nullptr;
  return raw;
}
 
template <typename T>
Box<T>::Box(uninit) noexcept {}
#endif // CXXBRIDGE1_RUST_BOX
 
#ifndef CXXBRIDGE1_RUST_BITCOPY
#define CXXBRIDGE1_RUST_BITCOPY
struct unsafe_bitcopy_t final {
  explicit unsafe_bitcopy_t() = default;
};
 
constexpr unsafe_bitcopy_t unsafe_bitcopy{};
#endif // CXXBRIDGE1_RUST_BITCOPY
 
#ifndef CXXBRIDGE1_RUST_VEC
#define CXXBRIDGE1_RUST_VEC
template <typename T>
class Vec final {
public:
  using value_type = T;
 
  Vec() noexcept;
  Vec(std::initializer_list<T>);
  Vec(const Vec &);
  Vec(Vec &&) noexcept;
  ~Vec() noexcept;
 
  Vec &operator=(Vec &&) noexcept;
  Vec &operator=(const Vec &);
 
  std::size_t size() const noexcept;
  bool empty() const noexcept;
  const T *data() const noexcept;
  T *data() noexcept;
  std::size_t capacity() const noexcept;
 
  const T &operator[](std::size_t n) const noexcept;
  const T &at(std::size_t n) const;
  const T &front() const noexcept;
  const T &back() const noexcept;
 
  T &operator[](std::size_t n) noexcept;
  T &at(std::size_t n);
  T &front() noexcept;
  T &back() noexcept;
 
  void reserve(std::size_t new_cap);
  void push_back(const T &value);
  void push_back(T &&value);
  template <typename... Args>
  void emplace_back(Args &&... args);
 
  using iterator = typename Slice<T>::iterator;
  iterator begin() noexcept;
  iterator end() noexcept;
 
  using const_iterator = typename Slice<const T>::iterator;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
 
  void swap(Vec &) noexcept;
 
  Vec(unsafe_bitcopy_t, const Vec &) noexcept;
 
private:
  void reserve_total(std::size_t cap) noexcept;
  void set_len(std::size_t len) noexcept;
  void drop() noexcept;
 
  friend void swap(Vec &lhs, Vec &rhs) noexcept { lhs.swap(rhs); }
 
  std::array<std::uintptr_t, 3> repr;
};
 
template <typename T>
Vec<T>::Vec(std::initializer_list<T> init) : Vec{} {
  this->reserve_total(init.size());
  std::move(init.begin(), init.end(), std::back_inserter(*this));
}
 
template <typename T>
Vec<T>::Vec(const Vec &other) : Vec() {
  this->reserve_total(other.size());
  std::copy(other.begin(), other.end(), std::back_inserter(*this));
}
 
template <typename T>
Vec<T>::Vec(Vec &&other) noexcept : repr(other.repr) {
  new (&other) Vec();
}
 
template <typename T>
Vec<T>::~Vec() noexcept {
  this->drop();
}
 
template <typename T>
Vec<T> &Vec<T>::operator=(Vec &&other) noexcept {
  if (this != &other) {
    this->drop();
    this->repr = other.repr;
    new (&other) Vec();
  }
  return *this;
}
 
template <typename T>
Vec<T> &Vec<T>::operator=(const Vec &other) {
  if (this != &other) {
    this->drop();
    new (this) Vec(other);
  }
  return *this;
}
 
template <typename T>
bool Vec<T>::empty() const noexcept {
  return this->size() == 0;
}
 
template <typename T>
T *Vec<T>::data() noexcept {
  return const_cast<T *>(const_cast<const Vec<T> *>(this)->data());
}
 
template <typename T>
const T &Vec<T>::operator[](std::size_t n) const noexcept {
  assert(n < this->size());
  auto data = reinterpret_cast<const char *>(this->data());
  return *reinterpret_cast<const T *>(data + n * size_of<T>());
}
 
template <typename T>
const T &Vec<T>::at(std::size_t n) const {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Vec index out of range");
  }
  return (*this)[n];
}
 
template <typename T>
const T &Vec<T>::front() const noexcept {
  assert(!this->empty());
  return (*this)[0];
}
 
template <typename T>
const T &Vec<T>::back() const noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}
 
template <typename T>
T &Vec<T>::operator[](std::size_t n) noexcept {
  assert(n < this->size());
  auto data = reinterpret_cast<char *>(this->data());
  return *reinterpret_cast<T *>(data + n * size_of<T>());
}
 
template <typename T>
T &Vec<T>::at(std::size_t n) {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Vec index out of range");
  }
  return (*this)[n];
}
 
template <typename T>
T &Vec<T>::front() noexcept {
  assert(!this->empty());
  return (*this)[0];
}
 
template <typename T>
T &Vec<T>::back() noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}
 
template <typename T>
void Vec<T>::reserve(std::size_t new_cap) {
  this->reserve_total(new_cap);
}
 
template <typename T>
void Vec<T>::push_back(const T &value) {
  this->emplace_back(value);
}
 
template <typename T>
void Vec<T>::push_back(T &&value) {
  this->emplace_back(std::move(value));
}
 
template <typename T>
template <typename... Args>
void Vec<T>::emplace_back(Args &&... args) {
  auto size = this->size();
  this->reserve_total(size + 1);
  ::new (reinterpret_cast<T *>(reinterpret_cast<char *>(this->data()) +
                               size * size_of<T>()))
      T(std::forward<Args>(args)...);
  this->set_len(size + 1);
}
 
template <typename T>
typename Vec<T>::iterator Vec<T>::begin() noexcept {
  return Slice<T>(this->data(), this->size()).begin();
}
 
template <typename T>
typename Vec<T>::iterator Vec<T>::end() noexcept {
  return Slice<T>(this->data(), this->size()).end();
}
 
template <typename T>
typename Vec<T>::const_iterator Vec<T>::begin() const noexcept {
  return this->cbegin();
}
 
template <typename T>
typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
  return this->cend();
}
 
template <typename T>
typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept {
  return Slice<const T>(this->data(), this->size()).begin();
}
 
template <typename T>
typename Vec<T>::const_iterator Vec<T>::cend() const noexcept {
  return Slice<const T>(this->data(), this->size()).end();
}
 
template <typename T>
void Vec<T>::swap(Vec &rhs) noexcept {
  using std::swap;
  swap(this->repr, rhs.repr);
}
 
template <typename T>
Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
#endif // CXXBRIDGE1_RUST_VEC
 
#ifndef CXXBRIDGE1_RUST_OPAQUE
#define CXXBRIDGE1_RUST_OPAQUE
class Opaque {
public:
  Opaque() = delete;
  Opaque(const Opaque &) = delete;
  ~Opaque() = delete;
};
#endif // CXXBRIDGE1_RUST_OPAQUE
 
#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
namespace detail {
namespace {
template <typename T, typename = std::size_t>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
} // namespace
} // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE
 
#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
class layout {
  template <typename T>
  friend std::size_t size_of();
  template <typename T>
  friend std::size_t align_of();
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return T::layout::size();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return sizeof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      size_of() {
    return do_size_of<T>();
  }
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return T::layout::align();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return alignof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      align_of() {
    return do_align_of<T>();
  }
};
 
template <typename T>
std::size_t size_of() {
  return layout::size_of<T>();
}
 
template <typename T>
std::size_t align_of() {
  return layout::align_of<T>();
}
#endif // CXXBRIDGE1_LAYOUT
} // namespace cxxbridge1
} // namespace rust
 
namespace graphcore {
  struct VertexType;
  enum class VertexSource : ::std::uint8_t;
  struct CategoryMemory;
  struct VertexMemory;
  struct ComputeSetMemory;
  struct MemoryByOverlappedness;
  struct Variable;
  struct VariableIdWithDebugIds;
  struct VariableBytes;
  struct TileMemory;
  struct MemoryWWOGaps;
  struct VertexMemoryVec;
  struct ComputeSetMemoryVec;
  struct TileRange;
  struct TileLiveBytes;
  struct ProgramStep;
  struct LoweredVar;
  struct VarCategory;
  struct EquivalenceClass;
  struct AllocationOrder;
  enum class ProgramType : ::std::uint8_t;
  struct ProgramTypeInfo;
  struct Program;
  struct CallInfo;
  struct OnTileExecuteInfo;
  struct DoExchangeInfo;
  struct InterIpuExchangeCycles;
  struct GlobalExchangeInfo;
  struct GlobalExchangeInfoAux;
  struct StreamCopyInfo;
  struct SyncInfoAux;
  struct SyncInfo;
  struct SansInfo;
  struct SyncAnsInfo;
  enum class SyncType : ::std::uint8_t;
  enum class TargetType : ::std::uint8_t;
  enum class IpuArch : ::std::uint8_t;
  struct PoplarVersion;
  struct VersionInfo;
  struct StreamCopy;
  struct InternalExchange;
  struct HostExchange;
  struct InterIpuExchange;
  struct Region;
  struct InstrumentationSettings;
  enum class ComputeInstrumentationLevel : ::std::uint8_t;
  enum class ExternalExchangeInstrumentationLevel : ::std::uint8_t;
  struct VertexCycleEstimateEntry;
  struct OptimizationInfoEntry;
  struct ComputeSetInfo;
  struct VertexCountsEntry;
  struct VertexCyclesEstimateEntry;
  struct TileCycleTotals;
  struct VertexInfo;
  struct Period;
  struct Run;
  struct StepRange;
  struct ProgramRange;
  struct CyclesInfo;
  struct CyclesRange;
  struct Step;
  struct TileCycles;
  struct IpuRange;
  struct EngineOption;
  struct DebugContextLocation;
  struct DebugContext;
  struct DynProfileAccess;
  struct DynDebugAccess;
}
 
namespace graphcore {
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexType
#define CXXBRIDGE1_STRUCT_graphcore$VertexType
struct VertexType final {
  ::rust::String name;
  ::std::uint64_t size;
  ::graphcore::VertexSource source;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexType
 
#ifndef CXXBRIDGE1_ENUM_graphcore$VertexSource
#define CXXBRIDGE1_ENUM_graphcore$VertexSource
enum class VertexSource : ::std::uint8_t {
  Cplusplus = 0,
  Asm = 1,
  Unknown = 2,
};
#endif // CXXBRIDGE1_ENUM_graphcore$VertexSource
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$MemoryByOverlappedness
#define CXXBRIDGE1_STRUCT_graphcore$MemoryByOverlappedness
struct MemoryByOverlappedness final {
  ::std::uint64_t non_overlapped;
  ::std::uint64_t overlapped;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$MemoryByOverlappedness
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$CategoryMemory
#define CXXBRIDGE1_STRUCT_graphcore$CategoryMemory
struct CategoryMemory final {
  ::graphcore::MemoryByOverlappedness interleaved;
  ::graphcore::MemoryByOverlappedness non_interleaved;
  ::graphcore::MemoryByOverlappedness overflowed;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$CategoryMemory
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexMemory
#define CXXBRIDGE1_STRUCT_graphcore$VertexMemory
struct VertexMemory final {
  ::std::uint64_t code_bytes;
  ::std::uint64_t copy_ptr_bytes;
  ::std::uint64_t descriptor_bytes;
  ::std::uint64_t edge_ptr_bytes;
  ::std::uint64_t padding_bytes;
  ::std::uint64_t vertex_data_bytes;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexMemory
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemory
#define CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemory
struct ComputeSetMemory final {
  ::std::uint64_t copy_ptr_bytes;
  ::std::uint64_t descriptor_bytes;
  ::std::uint64_t edge_ptr_bytes;
  ::std::uint64_t padding_bytes;
  ::std::uint64_t vertex_data_bytes;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemory
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Variable
#define CXXBRIDGE1_STRUCT_graphcore$Variable
struct Variable final {
  ::std::uint64_t id;
  ::rust::String name;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Variable
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VariableIdWithDebugIds
#define CXXBRIDGE1_STRUCT_graphcore$VariableIdWithDebugIds
struct VariableIdWithDebugIds final {
  ::std::uint64_t id;
  ::rust::Vec<::std::uint64_t> debug_ids;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VariableIdWithDebugIds
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VariableBytes
#define CXXBRIDGE1_STRUCT_graphcore$VariableBytes
struct VariableBytes final {
  ::std::uint64_t id;
  ::rust::String name;
  ::std::uint64_t bytes;
  ::rust::Vec<::std::uint64_t> bytes_worst_tiles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VariableBytes
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$MemoryWWOGaps
#define CXXBRIDGE1_STRUCT_graphcore$MemoryWWOGaps
struct MemoryWWOGaps final {
  ::std::uint64_t excluding_gaps;
  ::std::uint64_t including_gaps;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$MemoryWWOGaps
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$TileMemory
#define CXXBRIDGE1_STRUCT_graphcore$TileMemory
struct TileMemory final {
  ::graphcore::MemoryWWOGaps non_interleaved;
  ::graphcore::MemoryWWOGaps interleaved;
  ::graphcore::MemoryWWOGaps overflowed;
  ::graphcore::MemoryWWOGaps total;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$TileMemory
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexMemoryVec
#define CXXBRIDGE1_STRUCT_graphcore$VertexMemoryVec
struct VertexMemoryVec final {
  ::rust::Vec<::graphcore::VertexMemory> by_tile;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexMemoryVec
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemoryVec
#define CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemoryVec
struct ComputeSetMemoryVec final {
  ::rust::Vec<::graphcore::ComputeSetMemory> by_tile;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ComputeSetMemoryVec
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$TileRange
#define CXXBRIDGE1_STRUCT_graphcore$TileRange
struct TileRange final {
  ::std::uint64_t start;
  ::std::uint64_t end;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$TileRange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$TileLiveBytes
#define CXXBRIDGE1_STRUCT_graphcore$TileLiveBytes
struct TileLiveBytes final {
  ::std::uint32_t always_live;
  ::std::uint32_t not_always_live_max;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$TileLiveBytes
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ProgramStep
#define CXXBRIDGE1_STRUCT_graphcore$ProgramStep
struct ProgramStep final {
  ::std::size_t program;
  ::rust::Vec<::std::size_t> children;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ProgramStep
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$LoweredVar
#define CXXBRIDGE1_STRUCT_graphcore$LoweredVar
struct LoweredVar final {
  ::std::uint32_t id;
  bool allocated;
  ::std::uint32_t tile;
  ::rust::String name;
  ::std::uint32_t bytes;
  ::std::uint32_t alignment;
  ::std::uint32_t offset;
  ::std::uint32_t category;
  bool constant;
  bool always_live;
  bool executable;
  bool vertex_code;
  bool lowest_256kbytes;
  bool start_section;
  bool in_interleaved_mem;
  ::std::uint32_t equivalence_class;
  ::rust::Vec<::std::uint32_t> element_constraints;
  ::rust::Vec<::std::uint32_t> region_constraints;
  ::std::uint32_t unlowered_var_id;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$LoweredVar
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VarCategory
#define CXXBRIDGE1_STRUCT_graphcore$VarCategory
struct VarCategory final {
  ::std::uint32_t id;
  ::rust::String name;
  ::rust::String description;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VarCategory
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$EquivalenceClass
#define CXXBRIDGE1_STRUCT_graphcore$EquivalenceClass
struct EquivalenceClass final {
  ::std::uint32_t id;
  ::rust::Vec<::std::uint32_t> interference_ids;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$EquivalenceClass
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$AllocationOrder
#define CXXBRIDGE1_STRUCT_graphcore$AllocationOrder
struct AllocationOrder final {
  ::std::uint32_t tile;
  ::rust::Vec<::std::uint32_t> order;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$AllocationOrder
 
#ifndef CXXBRIDGE1_ENUM_graphcore$ProgramType
#define CXXBRIDGE1_ENUM_graphcore$ProgramType
enum class ProgramType : ::std::uint8_t {
  Unknown = 0,
  Sequence = 1,
  OnTileExecute = 2,
  Repeat = 3,
  RepeatWhile = 4,
  OnTileSwitch = 5,
  OnEveryTileSwitch = 6,
  IfElse = 7,
  DoExchange = 8,
  GlobalExchange = 9,
  StreamCopyBegin = 10,
  StreamCopyMid = 11,
  StreamCopyEnd = 12,
  WriteUndef = 13,
  Sync = 14,
  SetLocalConsensus = 15,
  SetLocalConsensusFromVar = 16,
  GetGlobalConsensus = 17,
  Sans = 18,
  Call = 19,
  SyncAns = 20,
};
#endif // CXXBRIDGE1_ENUM_graphcore$ProgramType
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$OnTileExecuteInfo
#define CXXBRIDGE1_STRUCT_graphcore$OnTileExecuteInfo
struct OnTileExecuteInfo final {
  ::std::size_t compute_set;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$OnTileExecuteInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$DoExchangeInfo
#define CXXBRIDGE1_STRUCT_graphcore$DoExchangeInfo
struct DoExchangeInfo final {
  ::std::size_t exchange_id;
  ::rust::Vec<::std::uint64_t> max_data_sent_and_received_by_ipu;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$DoExchangeInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfoAux
#define CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfoAux
struct GlobalExchangeInfoAux final {
  ::std::size_t exchange_id;
  ::rust::Vec<::graphcore::InterIpuExchangeCycles> cycles_by_tile;
  ::std::size_t sync_type_index;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfoAux
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$StreamCopyInfo
#define CXXBRIDGE1_STRUCT_graphcore$StreamCopyInfo
struct StreamCopyInfo final {
  ::std::size_t exchange_id;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$StreamCopyInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$SyncInfoAux
#define CXXBRIDGE1_STRUCT_graphcore$SyncInfoAux
struct SyncInfoAux final {
  ::std::size_t sync_type_index;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$SyncInfoAux
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$SansInfo
#define CXXBRIDGE1_STRUCT_graphcore$SansInfo
struct SansInfo final {
  ::std::uint32_t num_tiles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$SansInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$SyncAnsInfo
#define CXXBRIDGE1_STRUCT_graphcore$SyncAnsInfo
struct SyncAnsInfo final {
  ::std::uint32_t num_tiles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$SyncAnsInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$CallInfo
#define CXXBRIDGE1_STRUCT_graphcore$CallInfo
struct CallInfo final {
  ::std::size_t target;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$CallInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ProgramTypeInfo
#define CXXBRIDGE1_STRUCT_graphcore$ProgramTypeInfo
struct ProgramTypeInfo final {
  ::graphcore::OnTileExecuteInfo on_tile_execute;
  ::graphcore::DoExchangeInfo do_exchange;
  ::graphcore::GlobalExchangeInfoAux global_exchange;
  ::graphcore::StreamCopyInfo stream_copy;
  ::graphcore::SyncInfoAux sync;
  ::graphcore::SansInfo sans;
  ::graphcore::SyncAnsInfo sync_ans;
  ::graphcore::CallInfo call;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ProgramTypeInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Program
#define CXXBRIDGE1_STRUCT_graphcore$Program
struct Program final {
  ::rust::String name;
  ::rust::Vec<::std::size_t> children;
  ::graphcore::ProgramType program_type;
  ::graphcore::ProgramTypeInfo program_type_info;
  ::rust::Vec<::std::size_t> debug_id;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Program
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$InterIpuExchangeCycles
#define CXXBRIDGE1_STRUCT_graphcore$InterIpuExchangeCycles
struct InterIpuExchangeCycles final {
  ::std::uint64_t exchange;
  ::std::uint64_t sync;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$InterIpuExchangeCycles
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfo
#define CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfo
struct GlobalExchangeInfo final {
  ::std::size_t exchange_id;
  ::rust::Vec<::graphcore::InterIpuExchangeCycles> cycles_by_tile;
  ::graphcore::SyncType sync_type;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$GlobalExchangeInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$SyncInfo
#define CXXBRIDGE1_STRUCT_graphcore$SyncInfo
struct SyncInfo final {
  ::graphcore::SyncType sync_type;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$SyncInfo
 
#ifndef CXXBRIDGE1_ENUM_graphcore$SyncType
#define CXXBRIDGE1_ENUM_graphcore$SyncType
enum class SyncType : ::std::uint8_t {
  Internal = 0,
  GS1 = 1,
  GS2 = 2,
  GS3 = 3,
  GS4 = 4,
  Unknown = 5,
};
#endif // CXXBRIDGE1_ENUM_graphcore$SyncType
 
#ifndef CXXBRIDGE1_ENUM_graphcore$TargetType
#define CXXBRIDGE1_ENUM_graphcore$TargetType
enum class TargetType : ::std::uint8_t {
  Ipu = 0,
  IpuModel = 1,
  Cpu = 2,
};
#endif // CXXBRIDGE1_ENUM_graphcore$TargetType
 
#ifndef CXXBRIDGE1_ENUM_graphcore$IpuArch
#define CXXBRIDGE1_ENUM_graphcore$IpuArch
enum class IpuArch : ::std::uint8_t {
  Ipu1 = 0,
  Ipu2 = 1,
};
#endif // CXXBRIDGE1_ENUM_graphcore$IpuArch
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$PoplarVersion
#define CXXBRIDGE1_STRUCT_graphcore$PoplarVersion
struct PoplarVersion final {
  ::rust::String string;
  ::rust::String package_hash;
  ::std::uint32_t major;
  ::std::uint32_t minor;
  ::std::uint32_t point;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$PoplarVersion
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VersionInfo
#define CXXBRIDGE1_STRUCT_graphcore$VersionInfo
struct VersionInfo final {
  ::std::uint32_t major;
  ::std::uint32_t minor;
  ::std::uint32_t point;
  bool is_unstable_format;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VersionInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$StreamCopy
#define CXXBRIDGE1_STRUCT_graphcore$StreamCopy
struct StreamCopy final {
  ::rust::String stream;
  ::rust::String regions;
  ::std::uint32_t regions_id;
  bool is_remote_buffer;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$StreamCopy
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$InternalExchange
#define CXXBRIDGE1_STRUCT_graphcore$InternalExchange
struct InternalExchange final {
  ::rust::Vec<::std::uint32_t> bytes_received_by_tile;
  ::rust::Vec<::std::uint32_t> bytes_sent_by_tile;
  ::rust::Vec<::std::uint32_t> code_bytes_by_tile;
  ::rust::Vec<::std::uint64_t> estimated_cycles_by_tile;
  ::rust::String destination_vars;
  ::rust::String source_vars;
  ::std::uint32_t source_regions_id;
  ::std::uint32_t destination_regions_id;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$InternalExchange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$HostExchange
#define CXXBRIDGE1_STRUCT_graphcore$HostExchange
struct HostExchange final {
  ::rust::Vec<::std::uint32_t> bytes_received_by_tile;
  ::rust::Vec<::std::uint32_t> bytes_sent_by_tile;
  ::rust::Vec<::std::uint64_t> estimated_cycles_by_tile;
  ::rust::Vec<::graphcore::StreamCopy> to_ipu;
  ::rust::Vec<::graphcore::StreamCopy> from_ipu;
  ::rust::Vec<::graphcore::StreamCopy> from_host;
  ::rust::Vec<::graphcore::StreamCopy> to_host;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$HostExchange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$InterIpuExchange
#define CXXBRIDGE1_STRUCT_graphcore$InterIpuExchange
struct InterIpuExchange final {
  ::rust::Vec<::std::uint32_t> bytes_received_by_tile;
  ::rust::Vec<::std::uint32_t> bytes_sent_by_tile;
  ::rust::Vec<::std::uint64_t> estimated_cycles_by_tile;
  ::rust::String destination_vars;
  ::rust::String source_vars;
  ::std::uint32_t source_regions_id;
  ::std::uint32_t destination_regions_id;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$InterIpuExchange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Region
#define CXXBRIDGE1_STRUCT_graphcore$Region
struct Region final {
  ::std::uint32_t var_id;
  ::rust::String var_name;
  ::rust::String regions;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Region
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$InstrumentationSettings
#define CXXBRIDGE1_STRUCT_graphcore$InstrumentationSettings
struct InstrumentationSettings final {
  ::graphcore::ComputeInstrumentationLevel compute;
  ::graphcore::ExternalExchangeInstrumentationLevel external_exchange;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$InstrumentationSettings
 
#ifndef CXXBRIDGE1_ENUM_graphcore$ComputeInstrumentationLevel
#define CXXBRIDGE1_ENUM_graphcore$ComputeInstrumentationLevel
enum class ComputeInstrumentationLevel : ::std::uint8_t {
  Off = 0,
  Vertex = 1,
  Tile = 2,
  Ipu = 3,
  Device = 4,
  Unknown = 5,
};
#endif // CXXBRIDGE1_ENUM_graphcore$ComputeInstrumentationLevel
 
#ifndef CXXBRIDGE1_ENUM_graphcore$ExternalExchangeInstrumentationLevel
#define CXXBRIDGE1_ENUM_graphcore$ExternalExchangeInstrumentationLevel
enum class ExternalExchangeInstrumentationLevel : ::std::uint8_t {
  Off = 0,
  Tile = 1,
  Unknown = 2,
};
#endif // CXXBRIDGE1_ENUM_graphcore$ExternalExchangeInstrumentationLevel
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexCycleEstimateEntry
#define CXXBRIDGE1_STRUCT_graphcore$VertexCycleEstimateEntry
struct VertexCycleEstimateEntry final {
  ::std::size_t vertex_type_id;
  ::std::uint64_t active_cycles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexCycleEstimateEntry
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$OptimizationInfoEntry
#define CXXBRIDGE1_STRUCT_graphcore$OptimizationInfoEntry
struct OptimizationInfoEntry final {
  ::rust::String name;
  double value;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$OptimizationInfoEntry
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ComputeSetInfo
#define CXXBRIDGE1_STRUCT_graphcore$ComputeSetInfo
struct ComputeSetInfo final {
  ::rust::String name;
  ::rust::Vec<::graphcore::VertexCountsEntry> vertex_counts;
  ::rust::Vec<::graphcore::VertexCyclesEstimateEntry> vertex_estimated_active_cycles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ComputeSetInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexCountsEntry
#define CXXBRIDGE1_STRUCT_graphcore$VertexCountsEntry
struct VertexCountsEntry final {
  ::std::size_t vertex_type_id;
  ::std::uint32_t count;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexCountsEntry
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexCyclesEstimateEntry
#define CXXBRIDGE1_STRUCT_graphcore$VertexCyclesEstimateEntry
struct VertexCyclesEstimateEntry final {
  ::std::size_t vertex_type_id;
  ::std::uint64_t estimated_cycles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexCyclesEstimateEntry
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$TileCycleTotals
#define CXXBRIDGE1_STRUCT_graphcore$TileCycleTotals
struct TileCycleTotals final {
  ::std::uint64_t active_compute;
  ::std::uint64_t compute;
  ::std::uint64_t inter_ipu_exchange;
  ::std::uint64_t stream_copy_begin;
  ::std::uint64_t stream_copy;
  ::std::uint64_t stream_copy_end;
  ::std::uint64_t internal_exchange;
  ::std::uint64_t sync;
  ::std::uint64_t total;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$TileCycleTotals
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$VertexInfo
#define CXXBRIDGE1_STRUCT_graphcore$VertexInfo
struct VertexInfo final {
  ::std::uint64_t vertex_type;
  ::std::uint64_t cycles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$VertexInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Period
#define CXXBRIDGE1_STRUCT_graphcore$Period
struct Period final {
  ::std::uint64_t start;
  ::std::uint64_t end;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Period
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Run
#define CXXBRIDGE1_STRUCT_graphcore$Run
struct Run final {
  ::rust::String name;
  ::std::uint32_t num_programs;
  ::std::uint32_t first_step;
  ::std::uint32_t num_steps;
  ::graphcore::Period time_microseconds;
  ::rust::Vec<::graphcore::Period> cycles_by_ipu;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Run
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$StepRange
#define CXXBRIDGE1_STRUCT_graphcore$StepRange
struct StepRange final {
  ::std::uint64_t start;
  ::std::uint64_t end;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$StepRange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$ProgramRange
#define CXXBRIDGE1_STRUCT_graphcore$ProgramRange
struct ProgramRange final {
  ::std::uint64_t start;
  ::std::uint64_t end;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$ProgramRange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$CyclesInfo
#define CXXBRIDGE1_STRUCT_graphcore$CyclesInfo
struct CyclesInfo final {
  ::std::uint64_t min;
  ::std::uint64_t mean;
  ::std::uint64_t max;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$CyclesInfo
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$CyclesRange
#define CXXBRIDGE1_STRUCT_graphcore$CyclesRange
struct CyclesRange final {
  ::graphcore::CyclesInfo from;
  ::graphcore::CyclesInfo to;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$CyclesRange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$Step
#define CXXBRIDGE1_STRUCT_graphcore$Step
struct Step final {
  ::rust::String name;
  ::rust::Vec<::std::uint64_t> program;
  ::rust::Vec<::graphcore::CyclesRange> active_cycles_by_ipu;
  ::rust::Vec<::graphcore::CyclesRange> all_cycles_by_ipu;
  ::rust::Vec<::std::uint64_t> cycles_by_ipu;
  ::rust::Vec<::std::uint64_t> active_tiles_by_ipu;
  ::rust::Vec<float> thread_balance_by_ipu;
  ::rust::Vec<float> tile_balance_by_ipu;
  ::rust::Vec<float> active_tile_balance_by_ipu;
  ::rust::Vec<::std::uint64_t> data_out_by_ipu;
  ::rust::Vec<::std::uint64_t> data_in_by_ipu;
  ::rust::Vec<float> data_balance_by_ipu;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$Step
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$TileCycles
#define CXXBRIDGE1_STRUCT_graphcore$TileCycles
struct TileCycles final {
  ::rust::Vec<::std::uint64_t> cycles;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$TileCycles
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$IpuRange
#define CXXBRIDGE1_STRUCT_graphcore$IpuRange
struct IpuRange final {
  ::std::uint64_t start;
  ::std::uint64_t end;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$IpuRange
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$EngineOption
#define CXXBRIDGE1_STRUCT_graphcore$EngineOption
struct EngineOption final {
  ::rust::String name;
  ::rust::String value;
  bool is_default;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$EngineOption
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$DebugContextLocation
#define CXXBRIDGE1_STRUCT_graphcore$DebugContextLocation
struct DebugContextLocation final {
  ::rust::String file;
  ::std::uint32_t line;
  ::rust::String func;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$DebugContextLocation
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$DebugContext
#define CXXBRIDGE1_STRUCT_graphcore$DebugContext
struct DebugContext final {
  ::std::uint64_t id;
  ::rust::String name;
  ::rust::String layer;
  ::rust::Vec<::graphcore::DebugContextLocation> location;
  ::rust::Vec<::std::uint64_t> parent;
  ::rust::Vec<::std::uint64_t> children;
 
  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_graphcore$DebugContext
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$DynProfileAccess
#define CXXBRIDGE1_STRUCT_graphcore$DynProfileAccess
struct DynProfileAccess final : public ::rust::Opaque {
  ~DynProfileAccess() = delete;
 
private:
  friend ::rust::layout;
  struct layout {
    static ::std::size_t size() noexcept;
    static ::std::size_t align() noexcept;
  };
};
#endif // CXXBRIDGE1_STRUCT_graphcore$DynProfileAccess
 
#ifndef CXXBRIDGE1_STRUCT_graphcore$DynDebugAccess
#define CXXBRIDGE1_STRUCT_graphcore$DynDebugAccess
struct DynDebugAccess final : public ::rust::Opaque {
  ~DynDebugAccess() = delete;
 
private:
  friend ::rust::layout;
  struct layout {
    static ::std::size_t size() noexcept;
    static ::std::size_t align() noexcept;
  };
};
#endif // CXXBRIDGE1_STRUCT_graphcore$DynDebugAccess
 
::rust::Box<::graphcore::DynProfileAccess> read_profile_any(const ::rust::String &profile);
 
::rust::Vec<::graphcore::VertexMemory> get_memory_single_vertex_type(const ::graphcore::DynProfileAccess &p, ::std::uint32_t vertex_type);
 
::rust::Vec<::graphcore::CategoryMemory> get_memory_single_category(const ::graphcore::DynProfileAccess &p, ::rust::Str category);
 
::rust::Vec<::rust::String> memory_categories(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::CategoryMemory> get_memory_single_category_tiles(const ::graphcore::DynProfileAccess &p, ::rust::Str category, ::graphcore::TileRange tile_range);
 
::rust::Vec<::graphcore::ComputeSetMemoryVec> get_memory_all_compute_sets(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::VertexMemoryVec> get_memory_all_vertex_types(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::VertexMemoryVec> get_memory_all_vertex_types_tiles(const ::graphcore::DynProfileAccess &p, ::graphcore::TileRange tile_range);
 
::rust::Vec<::graphcore::TileLiveBytes> get_liveness_bytes_by_tile(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::TileMemory> get_tile_memory(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::TileMemory> get_tile_range_memory(const ::graphcore::DynProfileAccess &p, ::graphcore::TileRange tile_range);
 
::rust::Vec<::graphcore::VertexType> get_vertex_types(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::VariableBytes> get_liveness_always_live_variables_bytes(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::ProgramStep> get_liveness_program_steps(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t get_liveness_not_always_live_bytes_for_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t step);
 
::rust::Vec<::graphcore::VariableBytes> get_liveness_not_always_live_variables_for_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t step);
 
::rust::Vec<::graphcore::VariableBytes> get_liveness_not_always_live_variables_for_program_step_and_tile(const ::graphcore::DynProfileAccess &p, ::std::size_t step, ::std::size_t tile);
 
::rust::Vec<::graphcore::VariableBytes> get_liveness_not_always_live_variables_for_program_step_and_ipu(const ::graphcore::DynProfileAccess &p, ::std::size_t step, ::std::size_t ipu);
 
::std::uint64_t get_liveness_not_always_live_bytes_worst_tiles_for_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t step, ::std::size_t tile);
 
::rust::Vec<::std::uint64_t> get_liveness_not_always_live_bytes_by_program_step(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::uint64_t> get_liveness_not_always_live_bytes_for_ipu_by_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t ipu);
 
::rust::Vec<::std::uint64_t> get_liveness_not_always_live_bytes_for_tile_by_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t tile);
 
::rust::Vec<::std::uint64_t> get_liveness_not_always_live_bytes_for_var_id_by_program_step(const ::graphcore::DynProfileAccess &p, ::std::size_t var_id);
 
::rust::Vec<::std::uint64_t> get_liveness_not_always_live_bytes_for_var_name_by_program_step(const ::graphcore::DynProfileAccess &p, ::rust::String var_name);
 
::rust::Vec<::graphcore::Variable> variables(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::Program> programs(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::Program> programs_by_range(const ::graphcore::DynProfileAccess &p, ::graphcore::ProgramRange range);
 
::graphcore::Program get_program(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::rust::Vec<::std::size_t> control_programs(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::size_t> function_programs(const ::graphcore::DynProfileAccess &p);
 
::graphcore::CallInfo get_call_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::OnTileExecuteInfo get_on_tile_execute_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::DoExchangeInfo get_do_exchange_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::GlobalExchangeInfo get_global_exchange_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::StreamCopyInfo get_stream_copy_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::SyncInfo get_sync_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::SansInfo get_sans_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::graphcore::SyncAnsInfo get_sync_ans_info(const ::graphcore::DynProfileAccess &p, ::std::size_t prog);
 
::std::uint64_t num_ipus(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t tiles_per_ipu(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_tiles(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t bytes_per_tile(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t total_memory(const ::graphcore::DynProfileAccess &p);
 
double clock_frequency(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_replicas(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t ipus_per_replica(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t tiles_per_replica(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t memory_per_replica(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_vertices(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_edges(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_vars(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t num_compute_sets(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t bytes_per_ipu(const ::graphcore::DynProfileAccess &p);
 
::graphcore::TargetType target_type(const ::graphcore::DynProfileAccess &p);
 
::graphcore::IpuArch architecture(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t min_sync_delay(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::uint64_t> relative_sync_delay_by_tile(const ::graphcore::DynProfileAccess &p);
 
::graphcore::PoplarVersion poplar_version(const ::graphcore::DynProfileAccess &p);
 
::rust::String date_time(const ::graphcore::DynProfileAccess &p);
 
::graphcore::VersionInfo version(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::size_t> get_liveness_recorded_tiles(const ::graphcore::DynProfileAccess &p);
 
::graphcore::InstrumentationSettings instrumentation_settings(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::rust::String> compute_set_names(const ::graphcore::DynProfileAccess &p);
 
::graphcore::HostExchange host_exchange(const ::graphcore::DynProfileAccess &p, ::std::size_t exchange);
 
::rust::Vec<::graphcore::OptimizationInfoEntry> optimization_info(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::ComputeSetInfo> compute_set_infos(const ::graphcore::DynProfileAccess &p);
 
::graphcore::InternalExchange internal_exchange(const ::graphcore::DynProfileAccess &p, ::std::size_t exchange);
 
::graphcore::InterIpuExchange inter_ipu_exchange(const ::graphcore::DynProfileAccess &p, ::std::size_t exchange);
 
::std::uint64_t step_count(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t run_count(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::Run> runs(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::Step> get_steps(const ::graphcore::DynProfileAccess &p, ::graphcore::StepRange step_range);
 
bool lowered_vars_presence(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::Region> regions(const ::graphcore::DynProfileAccess &p, ::std::size_t regions_id);
 
::rust::Vec<::graphcore::TileCycles> get_all_tile_cycles_for_steps(const ::graphcore::DynProfileAccess &p, ::graphcore::StepRange step_range);
 
::graphcore::IpuRange profiled_ipus(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::EngineOption> execution_options(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::EngineOption> compilation_options(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::EngineOption> target_options(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::uint64_t> estimated_cycles_by_tile(const ::graphcore::DynProfileAccess &p, ::std::size_t compute_set);
 
::graphcore::TileCycleTotals tile_cycle_totals(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::uint64_t> cycles_by_tile(const ::graphcore::DynProfileAccess &p, ::std::size_t compute_set);
 
::rust::Vec<::std::uint64_t> cycles_by_ipu(const ::graphcore::DynProfileAccess &p, ::std::size_t compute_set);
 
::std::uint64_t cycles(const ::graphcore::DynProfileAccess &p, ::std::size_t compute_set);
 
::rust::Vec<::graphcore::VertexInfo> vertices(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::LoweredVar> lowered_vars_for_tile(const ::graphcore::DynProfileAccess &p, ::std::size_t tile);
 
::rust::Vec<::graphcore::LoweredVar> lowered_vars_for_var(const ::graphcore::DynProfileAccess &p, ::std::size_t var_id);
 
::rust::Vec<::graphcore::VarCategory> var_categories(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::EquivalenceClass> equivalence_classes(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::graphcore::AllocationOrder> allocation_order_by_tile(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t supervisor_instr_fetch_delay(const ::graphcore::DynProfileAccess &p);
 
::std::uint64_t interleaved_memory_start(const ::graphcore::DynProfileAccess &p);
 
::rust::Vec<::std::uint64_t> memory_element_offsets(const ::graphcore::DynProfileAccess &p);
 
::rust::Box<::graphcore::DynDebugAccess> read_debug_any(const ::rust::String &profile);
 
::rust::Vec<::std::uint64_t> debug_context_ids(const ::graphcore::DynDebugAccess &d, ::rust::String layer);
 
::rust::Vec<::std::uint64_t> first_level_debug_context_ids(const ::graphcore::DynDebugAccess &d);
 
::graphcore::DebugContext debug_context(const ::graphcore::DynDebugAccess &d, ::std::size_t debug_id);
 
::rust::String full_path(const ::graphcore::DynDebugAccess &d, ::std::size_t debug_id);
 
::rust::Vec<::std::size_t> program_ids_for_debug_ids(const ::graphcore::DynProfileAccess &p, ::rust::Vec<::std::size_t> debug_ids);
 
::rust::Vec<::graphcore::VariableIdWithDebugIds> var_ids_with_debug_ids(const ::graphcore::DynProfileAccess &p);
} // namespace graphcore