diff --git a/include/rosa/core/Message.hpp b/include/rosa/core/Message.hpp
index 7448d80..35613fd 100644
--- a/include/rosa/core/Message.hpp
+++ b/include/rosa/core/Message.hpp
@@ -1,304 +1,304 @@
 /*******************************************************************************
  *
  * File:     Message.hpp
  *
  * Contents: Declaration of Message base-class.
  *
  * Copyright 2017
  *
  * Author: David Juhasz (david.juhasz@tuwien.ac.at)
  *
  ******************************************************************************/
 
 #ifndef ROSA_CORE_MESSAGE_HPP
 #define ROSA_CORE_MESSAGE_HPP
 
 #include "rosa/support/log.h"
 #include "rosa/support/type_token.hpp"
 
 #include "rosa/core/forward_declarations.h"
 
 #include <memory>
 #include <vector>
 
 namespace rosa {
 
 // Message interface. The interface provides means to check the type of the
 // stored values, but actual data is to be managed by derived implementations.
 // Messages are immutable data objects, obtaining their data upon creation and
 // providing only constant references for the stored values.
 // NOTE: Any reference obtained from a Message instance remains valid only as
 // long as the owning Message object is not destroyed.
 class Message {
 protected:
   // Ctor.
   // NOTE: No implementation for empty list.
   template <typename Type, typename... Ts>
   Message(const Type &, const Ts &...) noexcept;
 
   // No copy and move.
   Message(const Message &) = delete;
   Message(Message &&) = delete;
   Message &operator=(const Message &) = delete;
   Message &operator=(Message &&) = delete;
 
 public:
   // Factory function to locally create a Message instance from constant
   // lvalue references.
   template <typename Type, typename... Types>
   static message_t create(const Type &T, const Types &... Ts) noexcept;
 
   // Factory function to locally create a Message instance from rvalue
   // references.
   template <typename Type, typename... Types>
   static message_t create(Type &&T, Types &&... Ts) noexcept;
 
   // A valid, non-empty token representing the types of the values stored in
   // the Message.
   const Token T;
 
   // The number of types encoded in T, that is the number of values stored in
   // Message.
   const size_t Size;
 
   // Virtual dtor.
   virtual ~Message(void);
 
   // Tells if the value in position Pos is of type Type.
   // NOTE: Token encodes atoms as AtomValue and not directly AtomConstants.
   // PRE: Pos < Size
   template <typename Type> bool isTypeAt(const size_t Pos) const noexcept;
 
   // Gives a constant reference of the value of type Type in position Pos.
   // PRE: Pos < Size && isTypeAt(Pos)
   template <typename Type> const Type &valueAt(const size_t Pos) const noexcept;
 
 protected:
   // Provides an untyped pointer for the value in position Pos.
   // PRE: Pos < Size
   virtual const void *pointerTo(const size_t Pos) const noexcept = 0;
 };
 
 // Nested namespace with an implementation for Message, consider it private.
 namespace {
 
 // Template class for an implementation of Message, definition below.
 template <typename... Types> class LocalMessage;
 
 // Initializes Arena with values from const lvalue references of Types.
 // NOTE: Arena needs to be a valid pointer to a memory area big enough for
 // values of Types.
 template <typename... Types>
 inline void createMessageElements(void *const Arena,
                                   const Types &... Ts) noexcept;
 
 // NOTE: This terminal case is used for both constant lvalue references and
 // value references.
 template <size_t Pos>
 inline void createMessageElement(void *const,
                                  const std::vector<size_t> &Offsets) {
   ASSERT(Pos == Offsets.size());
 }
 
-template <size_t Pos, AtomValue V, typename... Types>
-inline void
-createMessageElement(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;
-  createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
-}
-
 template <size_t Pos, typename Type, typename... Types>
 inline void createMessageElement(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);
   createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
 }
 
+template <size_t Pos, AtomValue V, typename... Types>
+inline void
+createMessageElement(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;
+  createMessageElement<Pos + 1>(Arena, Offsets, Ts...);
+}
+
 template <typename Type, typename... Types>
 inline void createMessageElements(void *const Arena, const Type &T,
                                   const Types &... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets, T,
                           Ts...);
 }
 
 // Initializes Arena with values from rvalue references of Types.
 // NOTE: Arena needs to be a valid pointer to a memory area big enough for
 // values of Types.
 template <typename... Types>
 inline void createMessageElements(void *const Arena, Types &&... Ts) noexcept;
 
-template <size_t Pos, AtomValue V, typename... Types>
-inline void createMessageElement(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;
-  createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
-}
-
 template <size_t Pos, typename Type, typename... Types>
 inline void createMessageElement(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));
   createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
 }
 
+template <size_t Pos, AtomValue V, typename... Types>
+inline void createMessageElement(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;
+  createMessageElement<Pos + 1>(Arena, Offsets, std::move(Ts)...);
+}
+
 template <typename Type, typename... Types>
 inline void createMessageElements(void *const Arena, Type &&T,
                                   Types &&... Ts) noexcept {
   ASSERT(Arena != nullptr);
   createMessageElement<0>(Arena, LocalMessage<Type, Types...>::Offsets,
                           std::move(T), std::move(Ts)...);
 }
 
 // Destroyes values of Types stored in Arena.
 // NOTE: Arena needs to be a valid pointer to a memory area where values of
 // Types are stored.
 template <typename Type, typename... Types>
 inline void destroyMessageElements(void *const Arena) noexcept;
 
 template <size_t Pos>
 inline void destroyMessageElement(void *const,
                                   const std::vector<size_t> &Offsets) noexcept {
   ASSERT(Pos == Offsets.size());
 }
 
 template <size_t Pos, typename Type, typename... Types>
 inline void destroyMessageElement(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();
   destroyMessageElement<Pos + 1, Types...>(Arena, Offsets);
 }
 
 template <typename Type, typename... Types>
 inline void destroyMessageElements(void *const Arena) noexcept {
   destroyMessageElement<0, Type, Types...>(
       Arena, LocalMessage<Type, Types...>::Offsets);
 }
 
 // Implementation of the template LocalMessage. Provides facilities for storing
 // values as a Message.
 template <typename Type, typename... Types>
 class LocalMessage<Type, Types...> : public Message {
 public:
   // Type Token for the stored values.
   // NOTE: Only for compile-time checks, static member is not defined.
   static constexpr Token ST =
       TypeToken<typename std::decay<Type>::type,
                 typename std::decay<Types>::type...>::Value;
 
   // Offsets required to access values in Arena.
   static const std::vector<size_t> Offsets;
 
 private:
   // A BLOB storing all the values one after the other.
   void *const Arena;
 
   // Generates offset for accessing values in Arena.
   static std::vector<size_t> offsets(void) noexcept {
     Token T = ST;                            // Need a mutable copy.
     size_t I = 0;                            // Start indexing from position 0.
     std::vector<size_t> O(lengthOfToken(T)); // Allocate vector of proper size.
     O[0] = 0;                                // First offset is always 0.
     while (!emptyToken(T)) {
       ASSERT(I < O.size());
       // Calculate next offset based on the previous one.
       O[I + 1] = O[I] + sizeOfHeadOfToken(T);
       dropHeadOfToken(T), ++I;
     }
     ASSERT(I == O.size());
     return O;
   }
 
 public:
   // Ctor for constant lvalue references.
   LocalMessage(const Type &T, const Types &... Ts) noexcept
       : Message(T, Ts...),
         Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(this->T == ST && Size == Offsets.size() &&
            Arena != nullptr); // Sanity check.
     createMessageElements(Arena, T, Ts...);
   }
 
   // Ctor for rvalue referecens.
   LocalMessage(Type &&T, Types &&... Ts) noexcept
       : Message(T, Ts...),
         Arena(::operator new(sizeOfValuesOfToken(ST))) {
     ASSERT(this->T == ST && Size == Offsets.size() &&
            Arena != nullptr); // Sanity check.
     createMessageElements(Arena, std::move(T), std::move(Ts)...);
   }
 
   // Dtor.
   ~LocalMessage(void) {
     destroyMessageElements<Type, Types...>(Arena);
     ::operator delete(Arena);
   }
 
   // Provides an untyped pointer for the constant value at Pos.
   const void *pointerTo(const size_t Pos) const noexcept override {
     ASSERT(Pos < Offsets.size());
     return static_cast<uint8_t *>(Arena) + Offsets[Pos];
   }
 };
 
 // Implementation of the static member field Offsets.
 template <typename Type, typename... Types>
 const std::vector<size_t> LocalMessage<Type, Types...>::Offsets =
     LocalMessage<Type, Types...>::offsets();
 
 } // End namespace
 
 template <typename Type, typename... Ts>
 Message::Message(const Type &, const Ts &...) noexcept
     : T(TypeToken<typename std::decay<Type>::type,
                   typename std::decay<Ts>::type...>::Value),
       Size(lengthOfToken(T)) {
   ASSERT(validToken(T) &&
          lengthOfToken(T) == (1 + sizeof...(Ts))); // Sanity check.
   LOG_TRACE("Creating Message with Token(" + to_string(T) + ")");
 }
 
 template <typename Type, typename... Types>
 message_t Message::create(const Type &T, const Types &... Ts) noexcept {
   return message_t(new LocalMessage<Type, Types...>(T, Ts...));
 }
 
 template <typename Type, typename... Types>
 message_t Message::create(Type &&T, Types &&... Ts) noexcept {
   return message_t(
       new LocalMessage<Type, Types...>(std::move(T), std::move(Ts)...));
 }
 
 template <typename Type>
 bool Message::isTypeAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size);
   Token T_ = T; // NOLINT
   dropNOfToken(T_, Pos);
   return isHeadOfTokenTheSameType<Type>(T_);
 }
 
 template <typename Type>
 const Type &Message::valueAt(const size_t Pos) const noexcept {
   ASSERT(Pos < Size && isTypeAt<Type>(Pos));
   return *static_cast<const Type *>(pointerTo(Pos));
 }
 
 } // End namespace rosa
 
 #endif // ROSA_CORE_MESSAGE_HPP