mesh_function_binary.h

 
#ifndef __9bad469d38e04e8ab67391ce50c2c480
#define __9bad469d38e04e8ab67391ce50c2c480
 
#include <type_traits>
#include <vector>
 
#include "mesh_function_traits.h"
 
namespace lf::mesh::utils {
 
template <class OP, class A, class B>
class MeshFunctionBinary {
 public:
  MeshFunctionBinary(OP op, A a, B b)
      : op_(std::move(op)), a_(std::move(a)), b_(std::move(b)) {}
 
  auto operator()(const lf::mesh::Entity& e,
                  const Eigen::MatrixXd& local) const {
    return op_(a_(e, local), b_(e, local), 0);
  }
 
 private:
  OP op_;
  A a_;
  B b_;
};
 
namespace internal {
 
struct OperatorAddition {
  template <class U, class V,
            class = typename std::enable_if<base::is_scalar<U> &&
                                            base::is_scalar<V>>::type>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v, int
                  /*unused*/) const {
    Eigen::Map<const Eigen::Matrix<U, 1, Eigen::Dynamic>> um(&u[0], 1,
                                                             u.size());
    Eigen::Map<const Eigen::Matrix<U, 1, Eigen::Dynamic>> vm(&v[0], 1,
                                                             v.size());
    std::vector<decltype(U(0) + V(0))> result(u.size());
    Eigen::Map<Eigen::Matrix<decltype(U(0) + V(0)), 1, Eigen::Dynamic>> rm(
        &result[0], 1, u.size());
    rm = um + vm;
    return result;
  }
 
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Matrix<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Matrix<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) + S2(0));
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic &&
                  R2 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // add two static size eigen matrices to each other
      static_assert(R1 == R2, "cannot add matrices with different #rows.");
      static_assert(C1 == C2, "cannot add matrices with different #cols.");
 
      Eigen::Map<const Eigen::Matrix<S1, 1, Eigen::Dynamic>> um(
          &u[0](0, 0), 1, u.size() * R1 * C1);
      Eigen::Map<const Eigen::Matrix<S2, 1, Eigen::Dynamic>> vm(
          &v[0](0, 0), 1, v.size() * R1 * C1);
 
      std::vector<Eigen::Matrix<scalar_t, R1, C1>> result(u.size());
      Eigen::Map<Eigen::Matrix<scalar_t, 1, Eigen::Dynamic>> rm(
          &result[0](0, 0), 1, u.size() * R1 * C1);
      rm = um + vm;
      return result;
    }
    if constexpr ((R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) ||
                  (R2 != Eigen::Dynamic && C2 != Eigen::Dynamic)) {  // NOLINT
      // One of the matrices is fixed size:
      constexpr int fixedRows = std::max(R1, R2);
      constexpr int fixedCols = std::max(C1, C2);
 
      std::vector<Eigen::Matrix<scalar_t, fixedRows, fixedCols>> result(
          u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].rows() == v[i].rows(),
                      "mismatch in #rows of matrices added to each other.");
        LF_ASSERT_MSG(u[i].cols() == v[i].cols(),
                      "mismatch in #cols of matrices added to each other.");
        result[i] = u[i] + v[i];
      }
      return result;
    } else {  // NOLINT
      // add two dynamic sized matrices:
      std::vector<Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].rows() == v[i].rows(),
                      "mismatch in #rows of matrices added to each other.");
        LF_ASSERT_MSG(u[i].cols() == v[i].cols(),
                      "mismatch in #cols of matrices added to each other.");
        result.emplace_back(u[i] + v[i]);
      }
      return result;
    }
  }
 
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Array<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Array<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) + S2(0));
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic &&
                  R2 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // add two static size eigen arrays to each other
      static_assert(R1 == R2, "cannot add arrays with different #rows.");
      static_assert(C1 == C2, "cannot add arrays with different #cols.");
 
      Eigen::Map<const Eigen::Array<S1, 1, Eigen::Dynamic>> um(
          &u[0](0, 0), 1, u.size() * R1 * C1);
      Eigen::Map<const Eigen::Array<S2, 1, Eigen::Dynamic>> vm(
          &v[0](0, 0), 1, v.size() * R1 * C1);
 
      std::vector<Eigen::Array<scalar_t, R1, C1>> result(u.size());
      Eigen::Map<Eigen::Array<scalar_t, 1, Eigen::Dynamic>> rm(
          &result[0](0, 0), 1, u.size() * R1 * C1);
      rm = um + vm;
      return result;
    }
    if constexpr ((R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) ||
                  (R2 != Eigen::Dynamic && C2 != Eigen::Dynamic)) {  // NOLINT
      // One of the arrays is fixed size:
      constexpr int fixedRows = std::max(R1, R2);
      constexpr int fixedCols = std::max(C1, C2);
 
      std::vector<Eigen::Array<scalar_t, fixedRows, fixedCols>> result(
          u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].rows() == v[i].rows(),
                      "mismatch in #rows of arrays added to each other.");
        LF_ASSERT_MSG(u[i].cols() == v[i].cols(),
                      "mismatch in #cols of arrays added to each other.");
        result[i] = u[i] + v[i];
      }
      return result;
    } else {  // NOLINT
      // add two dynamic sized arrays:
      std::vector<Eigen::Array<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].rows() == v[i].rows(),
                      "mismatch in #rows of arrays added to each other.");
        LF_ASSERT_MSG(u[i].cols() == v[i].cols(),
                      "mismatch in #cols of arrays added to each other.");
        result.emplace_back(u[i] + v[i]);
      }
      return result;
    }
  }
 
  template <class U, class V>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v,
                  long /*unused*/) const {
    std::vector<decltype(u[0] + v[0])> result(u.size());
    for (int i = 0; i < result.size(); ++i) {
      result[i] = u[i] + v[i];
    }
    return result;
  }
};
 
struct OperatorSubtraction {
  template <class U, class V,
            class = typename std::enable_if<base::is_scalar<U> &&
                                            base::is_scalar<V>>::type>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v, int
                  /*unused*/) const {
    Eigen::Map<const Eigen::Matrix<U, 1, Eigen::Dynamic>> um(&u[0], 1,
                                                             u.size());
    Eigen::Map<const Eigen::Matrix<U, 1, Eigen::Dynamic>> vm(&v[0], 1,
                                                             v.size());
    std::vector<decltype(U(0) + V(0))> result(u.size());
    Eigen::Map<Eigen::Matrix<decltype(U(0) + V(0)), 1, Eigen::Dynamic>> rm(
        &result[0], 1, u.size());
    rm = um - vm;
    return result;
  }
 
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Matrix<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Matrix<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) + S2(0));
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic &&
                  R2 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // subtract two static size eigen matrices from each other
      static_assert(R1 == R2, "cannot subtract matrices with different #rows.");
      static_assert(C1 == C2, "cannot subtract matrices with different #cols.");
 
      Eigen::Map<const Eigen::Matrix<S1, 1, Eigen::Dynamic>> um(
          &u[0](0, 0), 1, u.size() * R1 * C1);
      Eigen::Map<const Eigen::Matrix<S2, 1, Eigen::Dynamic>> vm(
          &v[0](0, 0), 1, v.size() * R1 * C1);
 
      std::vector<Eigen::Matrix<scalar_t, R1, C1>> result(u.size());
      Eigen::Map<Eigen::Matrix<scalar_t, 1, Eigen::Dynamic>> rm(
          &result[0](0, 0), 1, u.size() * R1 * C1);
      rm = um - vm;
      return result;
    }
    if constexpr ((R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) ||
                  (R2 != Eigen::Dynamic && C2 != Eigen::Dynamic)) {  // NOLINT
      // One of the matrices is fixed size:
      constexpr int fixedRows = std::max(R1, R2);
      constexpr int fixedCols = std::max(C1, C2);
 
      std::vector<Eigen::Matrix<scalar_t, fixedRows, fixedCols>> result(
          u.size());
      for (std::size_t i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of matrices subtracted from each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of matrices subtracted from each other.");
        result[i] = u[i] - v[i];
      }
      return result;
    } else {  // NOLINT
      // subtract two dynamic sized matrices from each other:
      std::vector<Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (unsigned long i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of matrices subtracted from each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of matrices subtracted from each other.");
        result.emplace_back(u[i] - v[i]);
      }
      return result;
    }
  }
 
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Array<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Array<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) - S2(0));
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic &&
                  R2 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // subtract two static size eigen arrays to each other
      static_assert(R1 == R2, "cannot subtract arrays with different #rows.");
      static_assert(C1 == C2, "cannot subtract arrays with different #cols.");
 
      Eigen::Map<const Eigen::Array<S1, 1, Eigen::Dynamic>> um(
          &u[0](0, 0), 1, u.size() * R1 * C1);
      Eigen::Map<const Eigen::Array<S2, 1, Eigen::Dynamic>> vm(
          &v[0](0, 0), 1, v.size() * R1 * C1);
 
      std::vector<Eigen::Array<scalar_t, R1, C1>> result(u.size());
      Eigen::Map<Eigen::Array<scalar_t, 1, Eigen::Dynamic>> rm(
          &result[0](0, 0), 1, u.size() * R1 * C1);
      rm = um - vm;
      return result;
    }
    if constexpr ((R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) ||
                  (R2 != Eigen::Dynamic && C2 != Eigen::Dynamic)) {  // NOLINT
      // One of the arrays is fixed size:
      constexpr int fixedRows = std::max(R1, R2);
      constexpr int fixedCols = std::max(C1, C2);
 
      std::vector<Eigen::Array<scalar_t, fixedRows, fixedCols>> result(
          u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of arrays subtracted from each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of arrays subtracted from each other.");
        result[i] = u[i] - v[i];
      }
      return result;
    } else {  // NOLINT
      // subtract two dynamic sized arrays:
      std::vector<Eigen::Array<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of arrays subtracted from each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of arrays subtracted from each other.");
        result.emplace_back(u[i] - v[i]);
      }
      return result;
    }
  }
 
  template <class U, class V>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v,
                  long /*unused*/) const {
    std::vector<decltype(u[0] + v[0])> result(u.size(),
                                              decltype(u[0] + v[0])());
    for (int i = 0; i < result.size(); ++i) {
      result[i] = u[i] - v[i];
    }
    return result;
  }
};
 
struct OperatorMultiplication {
  template <class U, class V,
            class = typename std::enable_if_t<base::is_scalar<U> &&
                                              base::is_scalar<V>>>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v, int
                  /*unused*/) const {
    Eigen::Map<const Eigen::Array<U, 1, Eigen::Dynamic>> um(&u[0], 1, u.size());
    Eigen::Map<const Eigen::Array<V, 1, Eigen::Dynamic>> vm(&v[0], 1, v.size());
    std::vector<decltype(U(0) * V(0))> result(u.size());
    Eigen::Map<Eigen::Array<decltype(U(0) * V(0)), 1, Eigen::Dynamic>> rm(
        &result[0], 1, u.size());
    rm = um * vm;
    return result;
  }
 
  // multiplication of fixed size eigen matrices
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Matrix<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Matrix<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) * S2(0));
    if constexpr (R1 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // The result is fixed size
      static_assert(C1 == Eigen::Dynamic || R2 == Eigen::Dynamic || C1 == R2,
                    "#cols of lhs doesn't match #rows of rhs");
 
      std::vector<Eigen::Matrix<scalar_t, R1, C2>> result(u.size());
      for (std::size_t i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].cols() == v[i].rows(),
                      "#cols of lhs doesn't match #rows of rhs");
        result[i] = u[i] * v[i];
      }
      return result;
    } else {  // NOLINT
      // multiply dynamic sized matrices
      std::vector<Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(u[i].cols() == v[i].rows(),
                      "#cols of lhs doesn't match #rows of rhs");
        result.emplace_back(u[i] * v[i]);
      }
      return result;
    }
  }
 
  template <class S1, int R1, int C1, int O1, int MR1, int MC1, class S2,
            int R2, int C2, int O2, int MR2, int MC2>
  auto operator()(const std::vector<Eigen::Array<S1, R1, C1, O1, MR1, MC1>>& u,
                  const std::vector<Eigen::Array<S2, R2, C2, O2, MR2, MC2>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(S1(0) * S2(0));
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic &&
                  R2 != Eigen::Dynamic && C2 != Eigen::Dynamic) {  // NOLINT
      // multiply two static size eigen arrays to each other
      static_assert(R1 == R2, "cannot multiply arrays with different #rows.");
      static_assert(C1 == C2, "cannot multiply arrays with different #cols.");
 
      Eigen::Map<const Eigen::Array<S1, 1, Eigen::Dynamic>> um(
          &u[0](0, 0), 1, u.size() * R1 * C1);
      Eigen::Map<const Eigen::Array<S2, 1, Eigen::Dynamic>> vm(
          &v[0](0, 0), 1, v.size() * R1 * C1);
 
      std::vector<Eigen::Array<scalar_t, R1, C1>> result(u.size());
      Eigen::Map<Eigen::Array<scalar_t, 1, Eigen::Dynamic>> rm(
          &result[0](0, 0), 1, u.size() * R1 * C1);
      rm = um * vm;
      return result;
    }
    if constexpr ((R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) ||
                  (R2 != Eigen::Dynamic && C2 != Eigen::Dynamic)) {  // NOLINT
      // One of the arrays is fixed size:
      constexpr int fixedRows = std::max(R1, R2);
      constexpr int fixedCols = std::max(C1, C2);
 
      std::vector<Eigen::Array<scalar_t, fixedRows, fixedCols>> result(
          u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of arrays multiplied with each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of arrays multiplied with each other.");
        result[i] = u[i] * v[i];
      }
      return result;
    } else {  // NOLINT
      // multiply two dynamic sized arrays:
      std::vector<Eigen::Array<scalar_t, Eigen::Dynamic, Eigen::Dynamic>>
          result;
      result.reserve(u.size());
      for (int i = 0; i < u.size(); ++i) {
        LF_ASSERT_MSG(
            u[i].rows() == v[i].rows(),
            "mismatch in #rows of arrays multiplied with each other.");
        LF_ASSERT_MSG(
            u[i].cols() == v[i].cols(),
            "mismatch in #cols of arrays multiplied with each other.");
        result.emplace_back(u[i] * v[i]);
      }
      return result;
    }
  }
 
  // multiplication of a scalar with matrix
  template <class U, class S1, int R1, int C1, int O1, int MR1, int MC1,
            class = std::enable_if_t<base::is_scalar<U>>>
  auto operator()(const std::vector<U>& u,
                  const std::vector<Eigen::Matrix<S1, R1, C1, O1, MR1, MC1>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(u[0] * v[0](0, 0));
    std::vector<Eigen::Matrix<scalar_t, R1, C1>> result(u.size());
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) {  // NOLINT
      // result is a static sized matrix:
      Eigen::Map<const Eigen::Array<S1, R1 * C1, Eigen::Dynamic>> vm(
          v[0].data(), R1 * C1, v.size());
      Eigen::Map<Eigen::Array<scalar_t, R1 * C1, Eigen::Dynamic>> rm(
          result[0].data(), R1 * C1, v.size());
      Eigen::Map<const Eigen::Array<U, 1, Eigen::Dynamic>> um(u.data(), 1,
                                                              u.size());
 
      rm = vm * um.template replicate<R1 * C1, 1>();
    } else {  // NOLINT
      // result is not static sized:
      for (std::size_t i = 0; i < u.size(); ++i) {
        result[i] = u[i] * v[i];
      }
    }
    return result;
  }
 
  // multiplication of matrix with scalar (other way around)
  template <class U, class S1, int R1, int C1, int O1, int MR1, int MC1,
            class = std::enable_if_t<base::is_scalar<U>>>
  auto operator()(const std::vector<Eigen::Matrix<S1, R1, C1, O1, MR1, MC1>>& v,
                  const std::vector<U>& u, int /*unused*/) const {
    return operator()(u, v, 0);
  }
 
  // multiplication of a scalar with array
  template <class U, class S1, int R1, int C1, int O1, int MR1, int MC1,
            class = std::enable_if_t<base::is_scalar<U>>>
  auto operator()(const std::vector<U>& u,
                  const std::vector<Eigen::Array<S1, R1, C1, O1, MR1, MC1>>& v,
                  int /*unused*/) const {
    using scalar_t = decltype(u[0] * v[0](0, 0));
    std::vector<Eigen::Array<scalar_t, R1, C1>> result(u.size());
    if constexpr (R1 != Eigen::Dynamic && C1 != Eigen::Dynamic) {
      // result is a static sized array:
      Eigen::Map<const Eigen::Array<S1, R1 * C1, Eigen::Dynamic>> vm(
          v[0].data(), R1 * C1, v.size());
      Eigen::Map<Eigen::Array<scalar_t, R1 * C1, Eigen::Dynamic>> rm(
          result[0].data(), R1 * C1, v.size());
      Eigen::Map<const Eigen::Array<U, 1, Eigen::Dynamic>> um(u.data(), 1,
                                                              u.size());
 
      rm = vm * um.template replicate<R1 * C1, 1>();
    } else {
      // result is not static sized:
      for (std::size_t i = 0; i < u.size(); ++i) {
        result[i] = u[i] * v[i];
      }
    }
    return result;
  }
 
  // multiplication of array with scalar (other way around)
  template <class U, class S1, int R1, int C1, int O1, int MR1, int MC1,
            class = std::enable_if_t<base::is_scalar<U>>>
  auto operator()(const std::vector<Eigen::Array<S1, R1, C1, O1, MR1, MC1>>& v,
                  const std::vector<U>& u, int /*unused*/) const {
    return operator()(u, v, 0);
  }
 
  // multiplication of arbitrary types supporting operator*:
  template <class U, class V>
  auto operator()(const std::vector<U>& u, const std::vector<V>& v,
                  long /*unused*/) const {
    std::vector<decltype(u[0] * v[0])> result;
    result.reserve(u.size());
    for (int i = 0; i < result.size(); ++i) {
      result.emplace_back(u[i] * v[i]);
    }
    return result;
  }
};
 
}  // namespace internal
 
template <class A, class B,
          class = std::enable_if_t<isMeshFunction<A> && isMeshFunction<B>>>
auto operator+(const A& a, const B& b) {
  return MeshFunctionBinary(internal::OperatorAddition{}, a, b);
}
 
template <class A, class B,
          class = std::enable_if_t<isMeshFunction<A> && isMeshFunction<B>>>
auto operator-(const A& a, const B& b) {
  return MeshFunctionBinary(internal::OperatorSubtraction{}, a, b);
}
 
template <class A, class B,
          class = std::enable_if_t<isMeshFunction<A> && isMeshFunction<B>>>
auto operator*(const A& a, const B& b) {
  return MeshFunctionBinary(internal::OperatorMultiplication{}, a, b);
}
 
}  // namespace lf::mesh::utils
 
#endif  // __9bad469d38e04e8ab67391ce50c2c480