diff --git a/include/rosa/support/tokenized_storages.hpp b/include/rosa/support/tokenized_storages.hpp
index e3acdfc..b11035a 100755
--- a/include/rosa/support/tokenized_storages.hpp
+++ b/include/rosa/support/tokenized_storages.hpp
@@ -1,629 +1,629 @@
 //===-- rosa/support/tokenized_storages.hpp ---------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/tokenized_storages.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Definition of storage helper template for storing values in a
 /// type-safe way based on type tokens.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_TOKENIZED_STORAGES_HPP
 #define ROSA_SUPPORT_TOKENIZED_STORAGES_HPP
 
 #include "rosa/support/log.h"
 #include "rosa/support/type_token.hpp"
 
 #include <memory>
 #include <vector>
 
 namespace rosa {
 
 /// Defines a simple interface for storing and accessing values of different
 /// types.
 ///
 /// While the interface provides features to access values and know their
 /// types, it is the users responsibility to use particular values according to
 /// their actual types. No facilities for type-safe access of values is
 /// provided by the class.
 ///
 /// \see \c rosa::TokenizedStorage for a type-safe specialization of the
 /// interface.
 class AbstractTokenizedStorage {
 protected:
   /// Protected constructor restricts instantiation for derived classes.
   AbstractTokenizedStorage(void) noexcept = default;
 
 public:
   /// No copying and moving of \c rosa::AbstractTokenizedStorage instances.
   ///@{
   AbstractTokenizedStorage(const AbstractTokenizedStorage &) = delete;
   AbstractTokenizedStorage &
   operator=(const AbstractTokenizedStorage &) = delete;
   AbstractTokenizedStorage(AbstractTokenizedStorage &&Other) = delete;
   AbstractTokenizedStorage &operator=(AbstractTokenizedStorage &&) = delete;
   ///@}
 
   /// Destroys \p this object.
   virtual ~AbstractTokenizedStorage(void) noexcept = default;
 
   /// Tells how many values are stored in \p this object.
   ///
   /// \return number of values stored in \p this object
   virtual size_t size(void) const noexcept = 0;
 
   /// Tells the type of the value stored at a position.
   ///
   /// \param Pos the index of the value whose type is to returned
   ///
   /// \return \c rosa::TypeNumber for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   virtual TypeNumber typeAt(const token_size_t Pos) const noexcept = 0;
 
   /// Provides an untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   virtual void *pointerTo(const token_size_t Pos) noexcept = 0;
 
   /// Provides a constant untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return constant untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   virtual const void *pointerTo(const token_size_t Pos) const noexcept = 0;
 };
 
 /// Template class storing values and providing dynamic type-safe access to
 /// them in a lightweight way based on type tokens.
 ///
 /// \see rosa/support/type_token.hpp
 ///
 /// \tparam Types types whose values are to be stored
 template <typename... Types> class TokenizedStorage;
 
 /// \defgroup TokenizedStorageForTypeList Implementation of
 /// rosa::TokenizedStorageForTypeList
 ///
 /// \brief Transforms a \c rosa::TypeList instance to the corresponding
 /// \c rosa::TokenizedStorage instance.
 ///
 /// A \c rosa::TypeList \c List instance can be turned into a corresponding \c
 /// rosa::TokenizedStorage instance as \code
 /// typename TokenizedStorageForTypeList<List>::Type
 /// \endcode
 ///
 /// For example, the following expression evaluates to `true`: \code
 /// std::is_same<typename TokenizedStorageForTypeList<TypeList<T1, T2>>::Type,
 ///              TokenizedStorage<T1, T2>>::value
 /// \endcode
 ///@{
 
 /// Declaration of the template.
 ///
 /// \tparam List \c rosa::TypeList to transform
 template <typename List> struct TokenizedStorageForTypeList;
 
 /// Implementation of the template for \c rosa::TypeList instances.
 template <typename... Ts> struct TokenizedStorageForTypeList<TypeList<Ts...>> {
   using Type = TokenizedStorage<Ts...>;
 };
 
 ///@}
 
 /// Nested namespace with implementation for \c rosa::TokenizedStorage, consider
 /// it private.
 namespace {
 
 /// Initializes a pre-allocated memory area with values from constant lvalue
 /// references.
 ///
 /// \tparam Types types whose values are to be stored
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts the values to store in \p Arena
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area big enough for
 /// values of \p Types.
 template <typename... Types>
 inline void createArenaElements(void *const Arena,
                                 const Types &... Ts) noexcept;
 
 /// \defgroup createLvalueArenaElement Implementation of creating lvalue arena
 /// elements
 ///
 /// Stores values from constant lvalue references into a pre-allocated memory
 /// area.
 ///
 /// \note To be used by the implementation of \c createArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 /// \note This terminal case is used for both constant lvalue references and
 /// value references.
 template <size_t Pos>
 inline void createArenaElement(void *const,
                                const std::vector<size_t> &Offsets) {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets,
                                const Type &T, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(static_cast<uint8_t *>(Arena) +
                                                Offsets[Pos]))) Type(T);
   createArenaElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void
 createArenaElement(void *const Arena, const std::vector<size_t> &Offsets,
                    const AtomConstant<V> &, const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createArenaElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to store
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts values to store in \p Arena
 ///
 /// \pre \p Arena is not \p nullptr.
 template <typename... Types>
 inline void createArenaElements(void *const Arena,
                                 const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createArenaElement<0>(Arena, TokenizedStorage<Types...>::Offsets, Ts...);
 }
 
 /// Initializes a pre-allocated memory area with values from rvalue references.
 ///
 /// \tparam Types types whose values are to be stored
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts the values to store in \p Arena
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area big enough for
 /// values of \p Types.
 template <typename... Types>
 inline void createArenaElements(void *const Arena, Types &&... Ts) noexcept;
 
 /// \defgroup createRvalueArenaElement Implementation of creating rvalue arena
 /// elements
 ///
 /// Stores values from rvalue references into a pre-allocated memory area.
 ///
 /// \note To be used by the implementation of \c createArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 template <size_t Pos, typename Type, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets, Type &&T,
                                Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   new (static_cast<Type *>(static_cast<void *>(
       static_cast<uint8_t *>(Arena) + Offsets[Pos]))) Type(std::move(T));
   createArenaElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 template <size_t Pos, AtomValue V, typename... Types>
 inline void createArenaElement(void *const Arena,
                                const std::vector<size_t> &Offsets,
                                AtomConstant<V> &&, Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   *static_cast<AtomValue *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos])) = V;
   createArenaElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to store
 ///
 /// \param Arena pre-allocated memory area to store values to
 /// \param Ts values to store in \p Arena
 ///
 /// \pre \p Arena is not \c nullptr.
 template <typename... Types>
 inline void createArenaElements(void *const Arena, Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createArenaElement<0>(Arena, TokenizedStorage<Types...>::Offsets,
                         std::move(Ts)...);
 }
 
 /// Destroys values allocated by \c createArenaElements.
 ///
 /// \tparam Types types whose values are stored in \p Arena
 ///
 /// \param Arena the memory area to destroy values from
 ///
 /// \note \p Arena needs to be a valid pointer to a memory area where values of
 /// \p Types are stored.
 template <typename... Types>
 inline void destroyArenaElements(void *const Arena) noexcept;
 
 /// \defgroup destroyArenaElement Implementation of destroying arena elements
 ///
 /// Destroys values from a memory area.
 ///
 /// \note To be used by the implementation of \c destroyArenaElements.
 ///
 /// \todo Document these functions.
 ///@{
 
 template <size_t Pos>
 inline void destroyArenaElement(void *const,
                                 const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void destroyArenaElement(void *const Arena,
                                 const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Arena != nullptr && Pos < Offsets.size());
   static_cast<Type *>(
       static_cast<void *>(static_cast<uint8_t *>(Arena) + Offsets[Pos]))
       ->~Type();
   destroyArenaElement<Pos + 1, Types...>(Arena, Offsets);
 }
 
 ///@}
 
 /// Implementation of the template.
 ///
 /// \tparam Types types of values to destroy
 ///
 /// \param Arena the memory area to destroy values from
 ///
 /// \pre \p Arena is not \c nullptr.
 template <typename... Types>
 inline void destroyArenaElements(void *const Arena) noexcept {
   ASSERT(Arena != nullptr);
   destroyArenaElement<0, Types...>(Arena, TokenizedStorage<Types...>::Offsets);
 }
 
 } // End namespace
 
 /// Implementation of the template \c rosa::TokenizedStorage as a
 /// specialization of \c rosa::AbstractTokenizedStorage.
 ///
 /// The class provides facilities for storing values and providing type-safe
 /// access to them.
 ///
 /// \tparam Types types of values to store
 template <typename... Types>
 class TokenizedStorage : public AbstractTokenizedStorage {
 public:
   /// \c rosa::Token for the stored values.
   static constexpr Token ST = TypeToken<std::decay_t<Types>...>::Value;
 
   /// Byte offsets to access stored values in \c rosa::TokenizedStorage::Arena.
   static const std::vector<size_t> Offsets;
 
 private:
   /// A BLOB storing all the values one after the other.
   void *const Arena;
 
   /// Generates byte offsets for accessing values stored in
   /// \c rosa::TokenizedStorage::Arena.
   ///
   /// \return \c std::vector containing byte offsets for accessing values stored
   /// in \c rosa::TokenizedStorage::Arena
   static std::vector<size_t> offsets(void) noexcept {
     Token T = ST;                            // Need a mutable copy.
     const token_size_t N = lengthOfToken(T); // Number of types encoded in \c T.
     std::vector<size_t> O(N);                // Allocate vector of proper size.
     // Do nothing for 0 elements.
     if (N > 0) {
       token_size_t I = 0; // Start indexing from position \c 0.
       O[0] = 0;           // First offset is always \c 0.
       while (I < N - 1) {
-        ASSERT(I + 1 < O.size() && lengthOfToken(T) == N - I);
+        ASSERT((size_t)I + 1 < O.size() && lengthOfToken(T) == N - I);
         // Calculate next offset based on the previous one.
         // \note The offset of the last value is stored at `O[N - 1]`, which is
         // set when `I == N - 2`. Hence the limit of the loop.
         O[I + 1] = O[I] + sizeOfHeadOfToken(T);
         dropHeadOfToken(T);
         ++I;
       }
-      ASSERT(I + 1 == O.size() && lengthOfToken(T) == 1);
+      ASSERT((size_t)I + 1 == O.size() && lengthOfToken(T) == 1);
     }
     return O;
   }
 
 public:
   /// Creates an instance with default values.
   ///
   /// \note This constructor requires that all actual template arguments \p
   /// Types... are default constructible.
   TokenizedStorage(void) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, Types()...);
   }
 
   /// Creates an instance from constant lvalue references.
   ///
   /// \param Ts values to store
   TokenizedStorage(const std::decay_t<Types> &... Ts) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, Ts...);
   }
 
   /// Creates an instance from rvalue references.
   ///
   /// \param Ts values to store
   TokenizedStorage(std::decay_t<Types> &&... Ts) noexcept
       : Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(Arena != nullptr); // Sanity check.
     createArenaElements(Arena, std::move(Ts)...);
   }
 
   /// No copying and moving of \c rosa::TokenizedStorage instances.
   ///
   /// \note This restriction may be relaxed as moving should be easy to
   /// implement, only requires the possiblity to validate Arena pointer.
   ///@{
   TokenizedStorage(const TokenizedStorage &) = delete;
   TokenizedStorage &operator=(const TokenizedStorage &) = delete;
   TokenizedStorage(TokenizedStorage &&Other) = delete;
   TokenizedStorage &operator=(TokenizedStorage &&) = delete;
   ///@}
 
   // Destroys \p this object.
   ~TokenizedStorage(void) {
     destroyArenaElements<std::decay_t<Types>...>(Arena);
     ::operator delete(Arena);
   }
 
   /// Tells how many values are stored in \p this object.
   ///
   /// \return number of values stored in \p this object
   size_t size(void) const noexcept override { return Offsets.size(); }
 
   /// Tells the type of the value stored at a position.
   ///
   /// \param Pos the index of the value whose type is to returned
   ///
   /// \return \c rosa::TypeNumber for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   TypeNumber typeAt(const token_size_t Pos) const noexcept override {
     ASSERT(Pos < size());
     Token TT = ST;
     dropNOfToken(TT, Pos);
     return headOfToken(TT);
   }
 
   /// Provides an untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < size()
   /// \endcode
   void *pointerTo(const token_size_t Pos) noexcept override {
     ASSERT(Pos < size());
     return static_cast<uint8_t *>(Arena) + Offsets[Pos];
   }
 
   /// Provides a constant untyped pointer for the value stored at a position.
   ///
   /// \param Pos the index of the value to return an untyped pointer for
   ///
   /// \return constant untyped pointer for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   const void *pointerTo(const token_size_t Pos) const noexcept override {
     ASSERT(Pos < size());
     return static_cast<const uint8_t *>(Arena) + Offsets[Pos];
   }
 
   /// Tells if the value stored at a given index is of a given type.
   ///
   /// \note Any \c rosa::AtomConstant is encoded in \c rosa::Token as
   /// the \c rosa::AtomValue wrapped into it.
   ///
   /// \tparam T type to match against
   ///
   /// \param Pos index the type of the value at is to be matched against \p Type
   ///
   /// \return if the value at index \p Pos of type \p T
   ///
   /// \pre \p Pos is a valid index:\code
   /// Pos < Offsets.size()
   /// \endcode
   template <typename T> bool isTypeAt(const size_t Pos) const noexcept {
     ASSERT(Pos < size());
     Token TT = ST;
     dropNOfToken(TT, Pos);
     return isHeadOfTokenTheSameType<T>(TT);
   }
 
   /// Gives a reference of a value of a given type stored at a given index.
   ///
   /// \note The constant variant of the function relies on this implementation,
   /// the function may not modify \p this object!
   ///
   /// \tparam T type to give a reference of
   ///
   /// \param Pos index to set the reference for
   ///
   /// \return reference of \p T for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index and the value at index \p Pos is of type
   /// \p T:
   /// \code
   /// Pos < Size && isTypeAt<T>(Pos)
   /// \endcode
   template <typename T> T &valueAt(const token_size_t Pos) noexcept {
     ASSERT(Pos < size() && isTypeAt<T>(Pos));
     return *static_cast<T *>(pointerTo(Pos));
   }
 
   /// Gives a constant reference of a value of a given type stored at a given
   /// index.
   ///
   /// \tparam T type to give a reference of
   ///
   /// \param Pos index to set the reference for
   ///
   /// \return constant reference of \p T for the value stored at index \p Pos
   ///
   /// \pre \p Pos is a valid index and the value at index \p Pos is of type
   /// \p T:
   /// \code
   /// Pos < Size && isTypeAt<T>(Pos)
   /// \endcode
   template <typename T>
   const T &valueAt(const token_size_t Pos) const noexcept {
     // \note Just use the non-const implementation as that does not modify
     // \p this object.
     return const_cast<TokenizedStorage *>(this)->valueAt<T>(Pos);
   }
 };
 
 // Implementation of the static member field \c rosa::TokenizedStorage::Offsets.
 template <typename... Types>
 const std::vector<size_t>
     TokenizedStorage<Types...>::Offsets = TokenizedStorage<Types...>::offsets();
 
 /// Specialization of the template \c rosa::TokenizedStorage for storing
 /// nothing.
 ///
 /// \note The specialization implements the interface defined by \c
 /// rosa::AbstractTokenizedStorage but most of the functions cannot be called
 /// because nothing is stored in instances of the class.
 template <> class TokenizedStorage<> : public AbstractTokenizedStorage {
 public:
   /// \c rosa::Token for the stored values.
   static constexpr Token ST = TypeToken<>::Value;
 
   /// Byte offsets to access stored values in \c rosa::TokenizedStorage::Arena.
   static const std::vector<size_t> Offsets;
 
   /// Creates an instance.
   TokenizedStorage(void) noexcept = default;
 
   /// No copying and moving of \c rosa::TokenizedStorage instances.
   ///
   /// \note This restriction may be relaxed as moving should be easy to
   /// implement, only requires the possiblity to validate Arena pointer.
   ///@{
   TokenizedStorage(const TokenizedStorage &) = delete;
   TokenizedStorage &operator=(const TokenizedStorage &) = delete;
   TokenizedStorage(TokenizedStorage &&Other) = delete;
   TokenizedStorage &operator=(TokenizedStorage &&) = delete;
   ///@}
 
   // Destroys \p this object.
   ~TokenizedStorage(void) override {}
 
   /// Tells how many values are stored in \p this object.
   ///
   /// \return `0`
   size_t size(void) const noexcept override { return 0; }
 
   /// Tells the type of the value stored at a position.
   ///
   /// \pre Do not call.
   TypeNumber typeAt(const token_size_t) const noexcept override {
     LOG_ERROR("Called unsupported function");
     return TypeNumber(0);
   }
 
   /// Provides an untyped pointer for the value stored at a position.
   ///
   /// \pre Do not call.
   void *pointerTo(const token_size_t) noexcept override {
     LOG_ERROR("Called unsupported function");
     return nullptr;
   }
 
   /// Provides a constant untyped pointer for the value stored at a position.
   ///
   /// \pre Do not call.
   const void *pointerTo(const token_size_t) const noexcept override {
     LOG_ERROR("Called unsupported function");
     return nullptr;
   }
 
   /// Tells if the value stored at a given index is of a given type.
   ///
   /// \pre Do not call.
   template <typename> bool isTypeAt(const size_t) const noexcept {
     LOG_ERROR("Called unsupported function");
     return false;
   }
 
   /// Gives a reference of a value of a given type stored at a given index.
   ///
   /// \tparam T type to give a reference of
   /// \pre Do not call.
   template <typename T> T &valueAt(const token_size_t) noexcept {
     LOG_ERROR("Called unsupported function");
     return *static_cast<T *>(nullptr);
   }
 
   /// Gives a constant reference of a value of a given type stored at a given
   /// index.
   ///
   /// \tparam T type to give a reference of
   ///
   /// \pre Do not call.
   template <typename T> const T &valueAt(const token_size_t) const noexcept {
     LOG_ERROR("Called unsupported function");
     // \note Just use the non-const implementation as that does not modify
     // \p this object.
     return *static_cast<T *>(nullptr);
   }
 };
 
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_TOKENIZED_STORAGES_HPP