XOD

// The sketch is auto-generated with XOD (https://xod.io).
//
// You can compile and upload it to an Arduino-compatible board with
// Arduino IDE.
//
// Rough code overview:
//
// - Configuration section
// - STL shim
// - Immutable list classes and functions
// - XOD runtime environment
// - Native node implementation
// - Program graph definition
//
// Search for comments fenced with '====' and '----' to navigate through
// the major code blocks.

#include <Arduino.h>
#include <inttypes.h>


/*=============================================================================
 *
 *
 * Configuration
 *
 *
 =============================================================================*/

// Uncomment to turn on debug of the program
//#define XOD_DEBUG

// Uncomment to trace the program runtime in the Serial Monitor
//#define XOD_DEBUG_ENABLE_TRACE


// Uncomment to make possible simulation of the program
//#define XOD_SIMULATION

#ifdef XOD_SIMULATION
#include <WasmSerial.h>
#define XOD_DEBUG_SERIAL WasmSerial
#else
#define XOD_DEBUG_SERIAL DEBUG_SERIAL
#endif

/*=============================================================================
 *
 *
 * STL shim. Provides implementation for vital std::* constructs
 *
 *
 =============================================================================*/

namespace xod {
namespace std {

template< class T > struct remove_reference      {typedef T type;};
template< class T > struct remove_reference<T&>  {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};

template <class T>
typename remove_reference<T>::type&& move(T&& a) {
    return static_cast<typename remove_reference<T>::type&&>(a);
}

} // namespace std
} // namespace xod

/*=============================================================================
 *
 *
 * Basic XOD types
 *
 *
 =============================================================================*/
namespace xod {
#if __SIZEOF_FLOAT__ == 4
typedef float Number;
#else
typedef double Number;
#endif
typedef bool Logic;
typedef unsigned long TimeMs;
typedef uint8_t DirtyFlags;
} // namespace xod

/*=============================================================================
 *
 *
 * XOD-specific list/array implementations
 *
 *
 =============================================================================*/

#ifndef XOD_LIST_H
#define XOD_LIST_H

namespace xod {
namespace detail {

/*
 * Cursors are used internaly by iterators and list views. They are not exposed
 * directly to a list consumer.
 *
 * The base `Cursor` is an interface which provides the bare minimum of methods
 * to facilitate a single iteration pass.
 */
template<typename T> class Cursor {
  public:
    virtual ~Cursor() { }
    virtual bool isValid() const = 0;
    virtual bool value(T* out) const = 0;
    virtual void next() = 0;
};

template<typename T> class NilCursor : public Cursor<T> {
  public:
    virtual bool isValid() const { return false; }
    virtual bool value(T*) const { return false; }
    virtual void next() { }
};

} // namespace detail

/*
 * Iterator is an object used to iterate a list once.
 *
 * Users create new iterators by calling `someList.iterate()`.
 * Iterators are created on stack and are supposed to have a
 * short live, e.g. for a duration of `for` loop or node’s
 * `evaluate` function. Iterators can’t be copied.
 *
 * Implemented as a pimpl pattern wrapper over the cursor.
 * Once created for a cursor, an iterator owns that cursor
 * and will delete the cursor object once destroyed itself.
 */
template<typename T>
class Iterator {
  public:
    static Iterator<T> nil() {
        return Iterator<T>(new detail::NilCursor<T>());
    }

    Iterator(detail::Cursor<T>* cursor)
        : _cursor(cursor)
    { }

    ~Iterator() {
        if (_cursor)
            delete _cursor;
    }

    Iterator(const Iterator& that) = delete;
    Iterator& operator=(const Iterator& that) = delete;

    Iterator(Iterator&& it)
        : _cursor(it._cursor)
    {
        it._cursor = nullptr;
    }

    Iterator& operator=(Iterator&& it) {
        auto tmp = it._cursor;
        it._cursor = _cursor;
        _cursor = tmp;
        return *this;
    }

    operator bool() const { return _cursor->isValid(); }

    bool value(T* out) const {
        return _cursor->value(out);
    }

    T operator*() const {
        T out;
        _cursor->value(&out);
        return out;
    }

    Iterator& operator++() {
        _cursor->next();
        return *this;
    }

  private:
    detail::Cursor<T>* _cursor;
};

/*
 * An interface for a list view. A particular list view provides a new
 * kind of iteration over existing data. This way we can use list slices,
 * list concatenations, list rotations, etc without introducing new data
 * buffers. We just change the way already existing data is iterated.
 *
 * ListView is not exposed to a list user directly, it is used internally
 * by the List class. However, deriving a new ListView is necessary if you
 * make a new list/string processing node.
 */
template<typename T> class ListView {
  public:
    virtual Iterator<T> iterate() const = 0;
};

/*
 * The list as it seen by data consumers. Have a single method `iterate`
 * to create a new iterator.
 *
 * Implemented as pimpl pattern wrapper over a list view. Takes pointer
 * to a list view in constructor and expects the view will be alive for
 * the whole life time of the list.
 */
template<typename T> class List {
  public:
    constexpr List()
        : _view(nullptr)
    { }

    List(const ListView<T>* view)
        : _view(view)
    { }

    Iterator<T> iterate() const {
        return _view ? _view->iterate() : Iterator<T>::nil();
    }

    // pre 0.15.0 backward compatibility
    List* operator->() __attribute__ ((deprecated)) { return this; }
    const List* operator->() const __attribute__ ((deprecated)) { return this; }

  private:
    const ListView<T>* _view;
};

/*
 * A list view over an old good plain C array.
 *
 * Expects the array will be alive for the whole life time of the
 * view.
 */
template<typename T> class PlainListView : public ListView<T> {
  public:
    class Cursor : public detail::Cursor<T> {
      public:
        Cursor(const PlainListView* owner)
            : _owner(owner)
            , _idx(0)
        { }

        bool isValid() const override {
            return _idx < _owner->_len;
        }

        bool value(T* out) const override {
            if (!isValid())
                return false;
            *out = _owner->_data[_idx];
            return true;
        }

        void next() override { ++_idx; }

      private:
        const PlainListView* _owner;
        size_t _idx;
    };

  public:
    PlainListView(const T* data, size_t len)
        : _data(data)
        , _len(len)
    { }

    virtual Iterator<T> iterate() const override {
        return Iterator<T>(new Cursor(this));
    }

  private:
    friend class Cursor;
    const T* _data;
    size_t _len;
};

/*
 * A list view over a null-terminated C-String.
 *
 * Expects the char buffer will be alive for the whole life time of the view.
 * You can use string literals as a buffer, since they are persistent for
 * the program execution time.
 */
class CStringView : public ListView<char> {
  public:
    class Cursor : public detail::Cursor<char> {
      public:
        Cursor(const char* str)
            : _ptr(str)
        { }

        bool isValid() const override {
            return (bool)*_ptr;
        }

        bool value(char* out) const override {
            *out = *_ptr;
            return (bool)*_ptr;
        }

        void next() override { ++_ptr; }

      private:
        const char* _ptr;
    };

  public:
    CStringView(const char* str = nullptr)
        : _str(str)
    { }

    CStringView& operator=(const CStringView& rhs) {
        _str = rhs._str;
        return *this;
    }

    virtual Iterator<char> iterate() const override {
        return _str ? Iterator<char>(new Cursor(_str)) : Iterator<char>::nil();
    }

  private:
    friend class Cursor;
    const char* _str;
};

/*
 * A list view over two other lists (Left and Right) which first iterates the
 * left one, and when exhausted, iterates the right one.
 *
 * Expects both Left and Right to be alive for the whole view life time.
 */
template<typename T> class ConcatListView : public ListView<T> {
  public:
    class Cursor : public detail::Cursor<T> {
      public:
        Cursor(Iterator<T>&& left, Iterator<T>&& right)
            : _left(std::move(left))
            , _right(std::move(right))
        { }

        bool isValid() const override {
            return _left || _right;
        }

        bool value(T* out) const override {
            return _left.value(out) || _right.value(out);
        }

        void next() override {
            _left ? ++_left : ++_right;
        }

      private:
        Iterator<T> _left;
        Iterator<T> _right;
    };

  public:
    ConcatListView() { }

    ConcatListView(List<T> left, List<T> right)
        : _left(left)
        , _right(right)
    { }

    ConcatListView& operator=(const ConcatListView& rhs) {
        _left = rhs._left;
        _right = rhs._right;
        return *this;
    }

    virtual Iterator<T> iterate() const override {
        return Iterator<T>(new Cursor(_left.iterate(), _right.iterate()));
    }

  private:
    friend class Cursor;
    List<T> _left;
    List<T> _right;
};

//----------------------------------------------------------------------------
// Text string helpers
//----------------------------------------------------------------------------

using XString = List<char>;

/*
 * List and list view in a single pack. An utility used to define constant
 * string literals in XOD.
 */
class XStringCString : public XString {
  public:
    XStringCString(const char* str)
        : XString(&_view)
        , _view(str)
    { }

  private:
    CStringView _view;
};

} // namespace xod

#endif

/*=============================================================================
 *
 *
 * Functions to work with memory
 *
 *
 =============================================================================*/
#ifdef __AVR__
// Placement `new` for Arduino
void* operator new(size_t, void* ptr) {
    return ptr;
}
#endif

/*=============================================================================
 *
 *
 * UART Classes, that wraps Serials
 *
 *
 =============================================================================*/

class HardwareSerial;
class SoftwareSerial;

namespace xod {

class Uart {
  private:
    long _baud;

  protected:
    bool _started = false;

  public:
    Uart(long baud) {
        _baud = baud;
    }

    virtual void begin() = 0;

    virtual void end() = 0;

    virtual void flush() = 0;

    virtual bool available() = 0;

    virtual bool writeByte(uint8_t) = 0;

    virtual bool readByte(uint8_t*) = 0;

    virtual SoftwareSerial* toSoftwareSerial() {
      return nullptr;
    }

    virtual HardwareSerial* toHardwareSerial() {
      return nullptr;
    }

    void changeBaudRate(long baud) {
      _baud = baud;
      if (_started) {
        end();
        begin();
      }
    }

    long getBaudRate() const {
      return _baud;
    }

    Stream* toStream() {
      Stream* stream = (Stream*) toHardwareSerial();
      if (stream) return stream;
      return (Stream*) toSoftwareSerial();
    }
};

class HardwareUart : public Uart {
  private:
    HardwareSerial* _serial;

  public:
    HardwareUart(HardwareSerial& hserial, uint32_t baud = 115200) : Uart(baud) {
      _serial = &hserial;
    }

    void begin();
    void end();
    void flush();

    bool available() {
      return (bool) _serial->available();
    }

    bool writeByte(uint8_t byte) {
      return (bool) _serial->write(byte);
    }

    bool readByte(uint8_t* out) {
      int data = _serial->read();
      if (data == -1) return false;
      *out = data;
      return true;
    }

    HardwareSerial* toHardwareSerial() {
      return _serial;
    }
};

void HardwareUart::begin() {
  _started = true;
  _serial->begin(getBaudRate());
};
void HardwareUart::end() {
  _started = false;
  _serial->end();
};
void HardwareUart::flush() {
  _serial->flush();
};

} // namespace xod

/*=============================================================================
 *
 *
 * Basic algorithms for XOD lists
 *
 *
 =============================================================================*/

#ifndef XOD_LIST_FUNCS_H
#define XOD_LIST_FUNCS_H



namespace xod {

/*
 * Folds a list from left. Also known as "reduce".
 */
template<typename T, typename TR>
TR foldl(List<T> xs, TR (*func)(TR, T), TR acc) {
    for (auto it = xs.iterate(); it; ++it)
        acc = func(acc, *it);
    return acc;
}

template<typename T> size_t lengthReducer(size_t len, T) {
    return len + 1;
}

/*
 * Computes length of a list.
 */
template<typename T> size_t length(List<T> xs) {
    return foldl(xs, lengthReducer<T>, (size_t)0);
}

template<typename T> T* dumpReducer(T* buff, T x) {
    *buff = x;
    return buff + 1;
}

/*
 * Copies a list content into a memory buffer.
 *
 * It is expected that `outBuff` has enough size to fit all the data.
 */
template<typename T> size_t dump(List<T> xs, T* outBuff) {
    T* buffEnd = foldl(xs, dumpReducer, outBuff);
    return buffEnd - outBuff;
}

/*
 * Compares two lists.
 */
template<typename T> bool equal(List<T> lhs, List<T> rhs) {
    auto lhsIt = lhs.iterate();
    auto rhsIt = rhs.iterate();

    for (; lhsIt && rhsIt; ++lhsIt, ++rhsIt) {
        if (*lhsIt != *rhsIt) return false;
    }

    return !lhsIt && !rhsIt;
}

template<typename T> bool operator == (List<T> lhs, List<T> rhs) {
  return equal(lhs, rhs);
}

} // namespace xod

#endif

/*=============================================================================
 *
 *
 * Format Numbers
 *
 *
 =============================================================================*/

/**
 * Provide `formatNumber` cross-platform number to string converter function.
 *
 * Taken from here:
 * https://github.com/client9/stringencoders/blob/master/src/modp_numtoa.c
 * Original function name: `modp_dtoa2`.
 *
 * Modified:
 * - `isnan` instead of tricky comparing and return "NaN"
 * - handle Infinity values and return "Inf" or "-Inf"
 * - return `OVF` and `-OVF` for numbers bigger than max possible, instead of using `sprintf`
 * - use `Number` instead of double
 * - if negative number rounds to zero, return just "0" instead of "-0"
 *
 * This is a replacement of `dtostrf`.
 */

#ifndef XOD_FORMAT_NUMBER_H
#define XOD_FORMAT_NUMBER_H

namespace xod {

/**
 * Powers of 10
 * 10^0 to 10^9
 */
static const Number powers_of_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000,
    10000000, 100000000, 1000000000 };

static void strreverse(char* begin, char* end) {
    char aux;
    while (end > begin)
        aux = *end, *end-- = *begin, *begin++ = aux;
};

size_t formatNumber(Number value, int prec, char* str) {
    if (isnan(value)) {
        strcpy(str, "NaN");
        return (size_t)3;
    }

    if (isinf(value)) {
        bool isNegative = value < 0;
        strcpy(str, isNegative ? "-Inf" : "Inf");
        return (size_t)isNegative ? 4 : 3;
    }

    /* if input is larger than thres_max return "OVF" */
    const Number thres_max = (Number)(0x7FFFFFFF);

    Number diff = 0.0;
    char* wstr = str;

    if (prec < 0) {
        prec = 0;
    } else if (prec > 9) {
        /* precision of >= 10 can lead to overflow errors */
        prec = 9;
    }

    /* we'll work in positive values and deal with the
     negative sign issue later */
    int neg = 0;
    if (value < 0) {
        neg = 1;
        value = -value;
    }

    uint32_t whole = (uint32_t)value;
    Number tmp = (value - whole) * powers_of_10[prec];
    uint32_t frac = (uint32_t)(tmp);
    diff = tmp - frac;

    if (diff > 0.5) {
        ++frac;
        /* handle rollover, e.g.  case 0.99 with prec 1 is 1.0  */
        if (frac >= powers_of_10[prec]) {
            frac = 0;
            ++whole;
        }
    } else if (diff == 0.5 && prec > 0 && (frac & 1)) {
        /* if halfway, round up if odd, OR
       if last digit is 0.  That last part is strange */
        ++frac;
        if (frac >= powers_of_10[prec]) {
            frac = 0;
            ++whole;
        }
    } else if (diff == 0.5 && prec == 0 && (whole & 1)) {
        ++frac;
        if (frac >= powers_of_10[prec]) {
            frac = 0;
            ++whole;
        }
    }

    if (value > thres_max) {
        if (neg) {
            strcpy(str, "-OVF");
            return (size_t)4;
        }
        strcpy(str, "OVF");
        return (size_t)3;
    }

    int has_decimal = 0;
    int count = prec;
    bool notzero = frac > 0;

    while (count > 0) {
        --count;
        *wstr++ = (char)(48 + (frac % 10));
        frac /= 10;
        has_decimal = 1;
    }

    if (frac > 0) {
        ++whole;
    }

    /* add decimal */
    if (has_decimal) {
        *wstr++ = '.';
    }

    notzero = notzero || whole > 0;

    /* do whole part
   * Take care of sign conversion
   * Number is reversed.
   */
    do
        *wstr++ = (char)(48 + (whole % 10));
    while (whole /= 10);

    if (neg && notzero) {
        *wstr++ = '-';
    }
    *wstr = '\0';
    strreverse(str, wstr - 1);
    return (size_t)(wstr - str);
}

} // namespace xod
#endif


/*=============================================================================
 *
 *
 * Runtime
 *
 *
 =============================================================================*/

//----------------------------------------------------------------------------
// Debug routines
//----------------------------------------------------------------------------
// #ifndef DEBUG_SERIAL
#if defined(XOD_DEBUG) && !defined(DEBUG_SERIAL)
#  define DEBUG_SERIAL Serial
#endif

#if defined(XOD_DEBUG) && defined(XOD_DEBUG_ENABLE_TRACE)
#  define XOD_TRACE(x)      { DEBUG_SERIAL.print(x); DEBUG_SERIAL.flush(); }
#  define XOD_TRACE_LN(x)   { DEBUG_SERIAL.println(x); DEBUG_SERIAL.flush(); }
#  define XOD_TRACE_F(x)    XOD_TRACE(F(x))
#  define XOD_TRACE_FLN(x)  XOD_TRACE_LN(F(x))
#else
#  define XOD_TRACE(x)
#  define XOD_TRACE_LN(x)
#  define XOD_TRACE_F(x)
#  define XOD_TRACE_FLN(x)
#endif

//----------------------------------------------------------------------------
// PGM space utilities
//----------------------------------------------------------------------------
#define pgm_read_nodeid(address) (pgm_read_word(address))

/*
 * Workaround for bugs:
 * https://github.com/arduino/ArduinoCore-sam/pull/43
 * https://github.com/arduino/ArduinoCore-samd/pull/253
 * Remove after the PRs merge
 */
#if !defined(ARDUINO_ARCH_AVR) && defined(pgm_read_ptr)
#  undef pgm_read_ptr
#  define pgm_read_ptr(addr) (*(const void **)(addr))
#endif

namespace xod {
//----------------------------------------------------------------------------
// Global variables
//----------------------------------------------------------------------------

TimeMs g_transactionTime;
bool g_isSettingUp;

//----------------------------------------------------------------------------
// Metaprogramming utilities
//----------------------------------------------------------------------------

template<typename T> struct always_false {
    enum { value = 0 };
};

//----------------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------------

TimeMs transactionTime();
void runTransaction();

//----------------------------------------------------------------------------
// Engine (private API)
//----------------------------------------------------------------------------

namespace detail {

template<typename NodeT>
bool isTimedOut(const NodeT* node) {
    TimeMs t = node->timeoutAt;
    // TODO: deal with uint32 overflow
    return t && t < transactionTime();
}

// Marks timed out node dirty. Do not reset timeoutAt here to give
// a chance for a node to get a reasonable result from `isTimedOut`
// later during its `evaluate`
template<typename NodeT>
void checkTriggerTimeout(NodeT* node) {
    node->isNodeDirty |= isTimedOut(node);
}

template<typename NodeT>
void clearTimeout(NodeT* node) {
    node->timeoutAt = 0;
}

template<typename NodeT>
void clearStaleTimeout(NodeT* node) {
    if (isTimedOut(node))
        clearTimeout(node);
}

} // namespace detail

//----------------------------------------------------------------------------
// Public API (can be used by native nodes’ `evaluate` functions)
//----------------------------------------------------------------------------

TimeMs transactionTime() {
    return g_transactionTime;
}

bool isSettingUp() {
    return g_isSettingUp;
}

template<typename ContextT>
void setTimeout(ContextT* ctx, TimeMs timeout) {
    ctx->_node->timeoutAt = transactionTime() + timeout;
}

template<typename ContextT>
void clearTimeout(ContextT* ctx) {
    detail::clearTimeout(ctx->_node);
}

template<typename ContextT>
bool isTimedOut(const ContextT* ctx) {
    return detail::isTimedOut(ctx->_node);
}

bool isValidDigitalPort(uint8_t port) {
#if defined(__AVR__) && defined(NUM_DIGITAL_PINS)
    return port < NUM_DIGITAL_PINS;
#else
    return true;
#endif
}

bool isValidAnalogPort(uint8_t port) {
#if defined(__AVR__) && defined(NUM_ANALOG_INPUTS)
    return port >= A0 && port < A0 + NUM_ANALOG_INPUTS;
#else
    return true;
#endif
}

} // namespace xod

//----------------------------------------------------------------------------
// Entry point
//----------------------------------------------------------------------------
void setup() {
    // FIXME: looks like there is a rounding bug. Waiting for 100ms fights it
    delay(100);

#if defined(XOD_DEBUG) || defined(XOD_SIMULATION)
    XOD_DEBUG_SERIAL.begin(115200);
    XOD_DEBUG_SERIAL.setTimeout(10);
#endif
    XOD_TRACE_FLN("\n\nProgram started");

    xod::g_isSettingUp = true;
    xod::runTransaction();
    xod::g_isSettingUp = false;
}

void loop() {
    xod::runTransaction();
}

/*=============================================================================
 *
 *
 * Native node implementations
 *
 *
 =============================================================================*/

namespace xod {

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/menu-base implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__menu_base {

//#pragma XOD dirtiness disable

/* Base classes for a BiDirectionalCursor oover a ListView,
   this adds the required virtual method "prev" for iterating in
   reverse-order, in addition to inheriting "next" */
template <typename T>
class BiDirectionalCursor : public detail::Cursor<T> {
 public:
  virtual void prev() = 0;
};

template <typename T>
class BiDirectionalNilCursor : public BiDirectionalCursor<T> {
  bool isValid() const { return false; }
  bool value(T*) const { return false; }
  void next() {}
  void prev() {}
};

/* Reverse iterator implementation */

template <typename T>
class ReverseIterator {
 public:
  static Iterator<T> nil() { return Iterator<T>(new detail::NilCursor<T>()); }

  explicit ReverseIterator(BiDirectionalCursor<T>* cursor) : _cursor(cursor) {}

  ReverseIterator(const ReverseIterator<T>&) = delete;
  ReverseIterator& operator=(const ReverseIterator<T>&) = delete;
  ReverseIterator(ReverseIterator<T>&& other) : _cursor(other._cursor) {
    other._cursor = nullptr;
  }

  ReverseIterator& operator=(ReverseIterator<T>&& other) {
    auto tmp = _cursor;
    _cursor = other._cursor;
    other._cursor = tmp;
    return *this;
  }

  operator bool() const { return _cursor.isValid(); }

  bool value(T* out) const { return _cursor.value(out); }

  T operator*() const {
    T out;
    _cursor->value(&out);
    return out;
  }

  ReverseIterator& operator--() {
    _cursor->prev();
    return *this;
  }

 private:
  BiDirectionalCursor<T>* _cursor;
};

template <typename T>
class BiDirectionalIterator;

/* A ListView which can return a bi-directional iterator
   via the "biterate" method, compare with the XOD library
   class "ListView" and "iterate" method. */

template <typename T>
class BiDirectionalListView : public ListView<T> {
 public:
  virtual BiDirectionalIterator<T> biterate() const = 0;

 protected:
  BiDirectionalListView() = default;
};

template <typename T>
class BiDirectionalList : public List<T> {
 public:
  constexpr BiDirectionalList() = default;

  explicit BiDirectionalList(const BiDirectionalListView<T>* view)
      : List<T>(view), _view(view) {}

  BiDirectionalIterator<T> biterate() const {
    return _view ? _view->biterate() : BiDirectionalIterator<T>::nil();
  }

 private:
   const BiDirectionalListView<T>* _view = nullptr;
};

/* A bi-directional iterator which functions similar to the XOD
   library class "Iterator" but can be iterated through forwards
   and backwards. Both forward-iterating past the end of the
   underlying container/array and backwards past the starting
   element will invalidate the iterator, and the user-defined
   conversion to bool will return false. */

template <typename T>
class BiDirectionalIterator {
 public:
  static BiDirectionalIterator<T> nil() {
    return BiDirectionalIterator<T>(new BiDirectionalNilCursor<T>());
  }

  BiDirectionalIterator(BiDirectionalCursor<T>* cursor)
      : _forward_iterator(cursor), _reverse_iterator(cursor) {}

  operator bool() const { return (bool)_forward_iterator; }

  bool value(T* out) const { return _forward_iterator.value(out); }

  T operator*() const {
    T out;
    _forward_iterator.value(&out);
    return out;
  }

  BiDirectionalIterator& operator++() {
    ++_forward_iterator;
    return *this;
  }

  BiDirectionalIterator& operator--() {
    --_reverse_iterator;
    return *this;
  }

 private:
  Iterator<T> _forward_iterator;
  ReverseIterator<T> _reverse_iterator;
};

/* A bi-directional list view over a good ol' C-style array. Compare
   XOD library class "PlainListView" */

template <typename T>
class BiDirectionalPlainListView : public BiDirectionalListView<T> {
  class Cursor : public BiDirectionalCursor<T> {
   public:
    explicit Cursor(const BiDirectionalPlainListView* owner) : _owner(owner), _idx(0) {}

    bool isValid() const override { return _valid; }

    bool value(T* out) const override {
      if (!isValid()) return false;
      *out = _owner->_data[_idx];
      return true;
    }

    void next() override {
      if (!(++_idx < _owner->_len)) {
        _valid = false;
      }
    }

    void prev() override { _idx != 0 ? --_idx : _valid = false; }

   private:
    const BiDirectionalPlainListView* _owner;
    size_t _idx;
    bool _valid = true;
  };

 public:
  BiDirectionalPlainListView(const T* data, size_t len)
      : _data(data), _len(len) {}

  Iterator<T> iterate() const override { return Iterator<T>(new Cursor(this)); }

  BiDirectionalIterator<T> biterate() const override {
    return BiDirectionalIterator<T>(new Cursor(this));
  }

 private:
  friend class BiDirectionalCursor<T>;
  const T* _data;
  size_t _len;
};

/* Base class tpye for all Menu instances representing a
   particular kind of menu that can be displayed and defines
   a minimal required set of interface methods. All Menu interface
   classes must derive from this base type so these base methods
   may be called polymorphically by the MenuController

   implementation. */

class MenuBase {
 public:
  virtual ~MenuBase() = default;

  List<XString> text() { return text_(); }

  MenuBase* invoke(Number param) { return invoke_(param); }

  uint8_t internal_id() const { return internal_id_; }

  uint8_t user_id() const { return user_id_; }

 protected:
  explicit MenuBase(uint8_t user_id) : user_id_(user_id),
           internal_id_(id_count()++) {}

 private:
   uint8_t user_id_ = 0;
   uint8_t internal_id_ = 0;

  static uint8_t& id_count() {
    static uint8_t id_count = 0;
    return id_count;
  }

  virtual List<XString> text_() = 0;
  virtual MenuBase* invoke_(Number) = 0;
};

/* Base interface class for a menu type, this can be further
   inherited from to define necessary non-virtual method calls
   for various types of menu items. */

template <typename MenuBase, template <typename> class MenuImpl>
class MenuInterface {
 public:
  List<XString> text() {
    return static_cast<MenuImpl<MenuBase>*>(this)->text_();
  }

  MenuBase* invoke() {
    return static_cast<MenuImpl<MenuBase>*>(this)->invoke_();
  }
};

using Type = MenuBase**;

/* The state is used to provide storage for a single base-type
   Menu pointer which will be assigned to a Leaf menu instance. */

struct State {
   MenuBase* leaf_menu_ptr = nullptr;
};

struct Node {
    State state;
    bitrex__xod_menu_system__menu_base::Type output_OUT;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct output_OUT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__menu_base::Type; };

struct ContextObject {
    Node* _node;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            "" \
            " output_OUT");
}

template<> bitrex__xod_menu_system__menu_base::Type getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT");
}

template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__menu_base::Type val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

/* An interface to a simp leaf-type menu, which cannot have further sub-menus
   called from it, and generates a pulse output plus a paramter change output
   when it's selected from the MenuController. Particular implementation
   behavior is injected using the CRTP/static polymorphism to avoid runtime
   overhead/program memory bloat. */

template <typename MenuBase, template <typename> class LeafMenuImpl>
class LeafMenuInterface : public MenuInterface<MenuBase, LeafMenuImpl> {
 public:
  void set_text(XString line1, XString line2) {
    static_cast<LeafMenuImpl<MenuBase>*>(this)->set_text_(line1, line2);
  }

  bool update(Number* out) {
    return static_cast<LeafMenuImpl<MenuBase>*>(this)->update_(out);
  }
};

/* Simple leaf menu implementation example */

template <typename MenuBase>
class LeafMenuImpl final : public LeafMenuInterface<MenuBase, LeafMenuImpl>,
                           public MenuBase {
  friend class MenuInterface<MenuBase, LeafMenuImpl>;
  friend class LeafMenuInterface<MenuBase, LeafMenuImpl>;

 public:
  LeafMenuImpl() : MenuBase(0), menu_text_lines_view_(nullptr, 0) {}

  LeafMenuImpl(XString line1, XString line2, uint8_t user_id)
      : MenuBase(user_id),
        lines_({line1, line2}),
        menu_text_lines_view_(PlainListView<XString>(lines_, 2)) {}

 protected:
  List<XString> text_() override {
    return List<XString>(&menu_text_lines_view_);
  }

  MenuBase* invoke_(Number param) override {
    invoked_ = true;
    param_ = param;
    return nullptr;
  }

  void set_text_(XString line1, XString line2) {
    lines_[0] = line1;
    lines_[1] = line2;
    menu_text_lines_view_ = PlainListView<XString>(lines_, 2);
  }

  bool update_(Number* out) {
    if (invoked_) {
      *out = param_;
      invoked_ = false;
      return true;
    }
    return false;
  }

 private:
  XString lines_[2];
  PlainListView<XString> menu_text_lines_view_;
  bool invoked_ = false;
  Number param_;
};

void evaluate(Context ctx) {
  if (isSettingUp()) {
    auto state = getState(ctx);
    emitValue<output_OUT>(ctx, &state->leaf_menu_ptr);
  }
}

} // namespace bitrex__xod_menu_system__menu_base

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/leaf-menu-item-impl implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__leaf_menu_item_impl {

//#pragma XOD dirtiness disable

namespace menu_base = ____menu_base;
using menu_base_t = menu_base::MenuBase;

using Type = menu_base::BiDirectionalList<menu_base_t*>;

struct State {
    menu_base::LeafMenuImpl<menu_base_t> leaf_menu;
    menu_base::BiDirectionalPlainListView<menu_base_t*> leaf_menu_view =
    menu_base::BiDirectionalPlainListView<menu_base_t*>(nullptr, 0);
};

struct Node {
    State state;
    TimeMs timeoutAt;
    bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;
    Number output_PARAM;
    Logic output_INVOKED;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isOutputDirty_PARAM : 1;
            bool isOutputDirty_INVOKED : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_MENU_PTR { };
struct input_LINE1 { };
struct input_LINE2 { };
struct input_ID { };
struct output_OUT { };
struct output_PARAM { };
struct output_INVOKED { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_MENU_PTR> { using T = bitrex__xod_menu_system__menu_base::Type; };
template<> struct ValueType<input_LINE1> { using T = XString; };
template<> struct ValueType<input_LINE2> { using T = XString; };
template<> struct ValueType<input_ID> { using T = uint8_t; };
template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };
template<> struct ValueType<output_PARAM> { using T = Number; };
template<> struct ValueType<output_INVOKED> { using T = Logic; };

struct ContextObject {
    Node* _node;

    bitrex__xod_menu_system__menu_base::Type _input_MENU_PTR;
    XString _input_LINE1;
    XString _input_LINE2;
    uint8_t _input_ID;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_MENU_PTR input_LINE1 input_LINE2 input_ID" \
            " output_OUT output_PARAM output_INVOKED");
}

template<> bitrex__xod_menu_system__menu_base::Type getValue<input_MENU_PTR>(Context ctx) {
    return ctx->_input_MENU_PTR;
}
template<> XString getValue<input_LINE1>(Context ctx) {
    return ctx->_input_LINE1;
}
template<> XString getValue<input_LINE2>(Context ctx) {
    return ctx->_input_LINE2;
}
template<> uint8_t getValue<input_ID>(Context ctx) {
    return ctx->_input_ID;
}
template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}
template<> Number getValue<output_PARAM>(Context ctx) {
    return ctx->_node->output_PARAM;
}
template<> Logic getValue<output_INVOKED>(Context ctx) {
    return ctx->_node->output_INVOKED;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT output_PARAM output_INVOKED");
}

template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}
template<> void emitValue<output_PARAM>(Context ctx, Number val) {
    ctx->_node->output_PARAM = val;
    ctx->_node->isOutputDirty_PARAM = true;
}
template<> void emitValue<output_INVOKED>(Context ctx, Logic val) {
    ctx->_node->output_INVOKED = val;
    ctx->_node->isOutputDirty_INVOKED = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    auto state = getState(ctx);
    auto line1 = getValue<input_LINE1>(ctx);
    auto line2 = getValue<input_LINE2>(ctx);

    if (isSettingUp())
    {
        using menu_base::BiDirectionalPlainListView;
        using menu_base::BiDirectionalList;
        using menu_base::LeafMenuImpl;

        const auto user_id = getValue<input_ID>(ctx);
        const auto menu_base_p2p = getValue<input_MENU_PTR>(ctx);
        state->leaf_menu_view = menu_base::BiDirectionalPlainListView<menu_base_t*>(menu_base_p2p, 1);
        state->leaf_menu = LeafMenuImpl<menu_base_t>(line1, line2, user_id);
        *menu_base_p2p = &state->leaf_menu;
        emitValue<output_OUT>(ctx,  menu_base::BiDirectionalList<menu_base_t*>(&state->leaf_menu_view));
        setTimeout(ctx, 10);
    }

    if (isTimedOut(ctx)) {
        auto menu_base_ptr = *state->leaf_menu_view.iterate();
        state->leaf_menu.set_text(line1, line2);
        Number out;
        auto invoked = state->leaf_menu.update(&out);
        if (invoked) {
         emitValue<output_INVOKED>(ctx, 1);
         emitValue<output_PARAM>(ctx, out);
        }
        setTimeout(ctx, 10);
    }
}

} // namespace bitrex__xod_menu_system__leaf_menu_item_impl

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/flash-string-1 implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__flash_string_1 {

//#pragma XOD dirtiness disable

class FlashStringView : public ListView<char> {
 public:
  class Cursor : public detail::Cursor<char> {
   public:
    Cursor(const char PROGMEM* str) : _ptr(str) {}

    bool isValid() const override {
      return static_cast<bool>(static_cast<char>(pgm_read_byte(_ptr)));
    }

    bool value(char* out) const override {
      *out = static_cast<char>(pgm_read_byte(_ptr));
      return static_cast<bool>(*out);
    }

    void next() override { ++_ptr; }

   private:
    const char PROGMEM* _ptr;
  };

 public:
  FlashStringView(const char PROGMEM* str = nullptr) : _str(str) {}
  FlashStringView(const __FlashStringHelper* str)
      : _str(reinterpret_cast<const char PROGMEM*>(str)) {}

  FlashStringView& operator=(const FlashStringView& rhs) {
    _str = rhs._str;
    return *this;
  }

  virtual Iterator<char> iterate() const override {
    return _str ? Iterator<char>(new Cursor(_str)) : Iterator<char>::nil();
  }

 private:
  friend class Cursor;
  const char PROGMEM* _str;
};

class XStringFlashString : public XString {
 public:
  XStringFlashString(const char PROGMEM* str) : XString(&_view), _view(str) {}

  XStringFlashString(const __FlashStringHelper* str)
      : XString(&_view), _view(str) {}

 private:
  FlashStringView _view;
};

struct State {
};

struct Node {
    State state;
    XString output_TXT;

    union {
        struct {
            bool isOutputDirty_TXT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct output_TXT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<output_TXT> { using T = XString; };

struct ContextObject {
    Node* _node;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            "" \
            " output_TXT");
}

template<> XString getValue<output_TXT>(Context ctx) {
    return ctx->_node->output_TXT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_TXT");
}

template<> void emitValue<output_TXT>(Context ctx, XString val) {
    ctx->_node->output_TXT = val;
    ctx->_node->isOutputDirty_TXT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

const char text[] PROGMEM = {"Make XOD Menus!"};
static XStringFlashString out_text = XStringFlashString(text);

void evaluate(Context ctx) {
    if (isSettingUp()) {
        emitValue<output_TXT>(ctx, out_text);
    }
}

} // namespace bitrex__xod_menu_system__flash_string_1

//-----------------------------------------------------------------------------
// xod/core/continuously implementation
//-----------------------------------------------------------------------------
namespace xod__core__continuously {

struct State {
};

struct Node {
    State state;
    TimeMs timeoutAt;
    Logic output_TICK;

    union {
        struct {
            bool isOutputDirty_TICK : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct output_TICK { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<output_TICK> { using T = Logic; };

struct ContextObject {
    Node* _node;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            "" \
            " output_TICK");
}

template<> Logic getValue<output_TICK>(Context ctx) {
    return ctx->_node->output_TICK;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_TICK");
}

template<> void emitValue<output_TICK>(Context ctx, Logic val) {
    ctx->_node->output_TICK = val;
    ctx->_node->isOutputDirty_TICK = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    emitValue<output_TICK>(ctx, 1);
    setTimeout(ctx, 0);
}

} // namespace xod__core__continuously

//-----------------------------------------------------------------------------
// xod/gpio/analog-read implementation
//-----------------------------------------------------------------------------
namespace xod__gpio__analog_read {

struct State {
};

struct Node {
    State state;
    Number output_VAL;
    Logic output_DONE;
    Logic output_ERR;

    union {
        struct {
            bool isOutputDirty_VAL : 1;
            bool isOutputDirty_DONE : 1;
            bool isOutputDirty_ERR : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_PORT { };
struct input_UPD { };
struct output_VAL { };
struct output_DONE { };
struct output_ERR { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_PORT> { using T = uint8_t; };
template<> struct ValueType<input_UPD> { using T = Logic; };
template<> struct ValueType<output_VAL> { using T = Number; };
template<> struct ValueType<output_DONE> { using T = Logic; };
template<> struct ValueType<output_ERR> { using T = Logic; };

struct ContextObject {
    Node* _node;

    uint8_t _input_PORT;
    Logic _input_UPD;

    bool _isInputDirty_UPD;
};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_PORT input_UPD" \
            " output_VAL output_DONE output_ERR");
}

template<> uint8_t getValue<input_PORT>(Context ctx) {
    return ctx->_input_PORT;
}
template<> Logic getValue<input_UPD>(Context ctx) {
    return ctx->_input_UPD;
}
template<> Number getValue<output_VAL>(Context ctx) {
    return ctx->_node->output_VAL;
}
template<> Logic getValue<output_DONE>(Context ctx) {
    return ctx->_node->output_DONE;
}
template<> Logic getValue<output_ERR>(Context ctx) {
    return ctx->_node->output_ERR;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            " input_UPD");
    return false;
}

template<> bool isInputDirty<input_UPD>(Context ctx) {
    return ctx->_isInputDirty_UPD;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_VAL output_DONE output_ERR");
}

template<> void emitValue<output_VAL>(Context ctx, Number val) {
    ctx->_node->output_VAL = val;
    ctx->_node->isOutputDirty_VAL = true;
}
template<> void emitValue<output_DONE>(Context ctx, Logic val) {
    ctx->_node->output_DONE = val;
    ctx->_node->isOutputDirty_DONE = true;
}
template<> void emitValue<output_ERR>(Context ctx, Logic val) {
    ctx->_node->output_ERR = val;
    ctx->_node->isOutputDirty_ERR = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    if (!isInputDirty<input_UPD>(ctx))
        return;

    const uint8_t port = getValue<input_PORT>(ctx);

    if (!isValidAnalogPort(port)) {
        emitValue<output_ERR>(ctx, 1);
        return;
    }

    ::pinMode(port, INPUT);
    emitValue<output_VAL>(ctx, ::analogRead(port) / 1023.);
    emitValue<output_DONE>(ctx, 1);
}

} // namespace xod__gpio__analog_read

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/text-lcd-16x2-keypad-impl implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__text_lcd_16x2_keypad_impl {

struct State {
  const size_t num_keys = 5;
  const float adc_key_val[5] = {0.05f, 0.15f, 0.35f, 0.55f, 0.75f};
};

struct Node {
    State state;
    Logic output_RIGHT;
    Logic output_LEFT;
    Logic output_UP;
    Logic output_DOWN;
    Logic output_SELECT;

    union {
        struct {
            bool isOutputDirty_RIGHT : 1;
            bool isOutputDirty_LEFT : 1;
            bool isOutputDirty_UP : 1;
            bool isOutputDirty_DOWN : 1;
            bool isOutputDirty_SELECT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_ADC_IN { };
struct output_RIGHT { };
struct output_LEFT { };
struct output_UP { };
struct output_DOWN { };
struct output_SELECT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_ADC_IN> { using T = Number; };
template<> struct ValueType<output_RIGHT> { using T = Logic; };
template<> struct ValueType<output_LEFT> { using T = Logic; };
template<> struct ValueType<output_UP> { using T = Logic; };
template<> struct ValueType<output_DOWN> { using T = Logic; };
template<> struct ValueType<output_SELECT> { using T = Logic; };

struct ContextObject {
    Node* _node;

    Number _input_ADC_IN;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_ADC_IN" \
            " output_RIGHT output_LEFT output_UP output_DOWN output_SELECT");
}

template<> Number getValue<input_ADC_IN>(Context ctx) {
    return ctx->_input_ADC_IN;
}
template<> Logic getValue<output_RIGHT>(Context ctx) {
    return ctx->_node->output_RIGHT;
}
template<> Logic getValue<output_LEFT>(Context ctx) {
    return ctx->_node->output_LEFT;
}
template<> Logic getValue<output_UP>(Context ctx) {
    return ctx->_node->output_UP;
}
template<> Logic getValue<output_DOWN>(Context ctx) {
    return ctx->_node->output_DOWN;
}
template<> Logic getValue<output_SELECT>(Context ctx) {
    return ctx->_node->output_SELECT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_RIGHT output_LEFT output_UP output_DOWN output_SELECT");
}

template<> void emitValue<output_RIGHT>(Context ctx, Logic val) {
    ctx->_node->output_RIGHT = val;
    ctx->_node->isOutputDirty_RIGHT = true;
}
template<> void emitValue<output_LEFT>(Context ctx, Logic val) {
    ctx->_node->output_LEFT = val;
    ctx->_node->isOutputDirty_LEFT = true;
}
template<> void emitValue<output_UP>(Context ctx, Logic val) {
    ctx->_node->output_UP = val;
    ctx->_node->isOutputDirty_UP = true;
}
template<> void emitValue<output_DOWN>(Context ctx, Logic val) {
    ctx->_node->output_DOWN = val;
    ctx->_node->isOutputDirty_DOWN = true;
}
template<> void emitValue<output_SELECT>(Context ctx, Logic val) {
    ctx->_node->output_SELECT = val;
    ctx->_node->isOutputDirty_SELECT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
  auto state = getState(ctx);
  auto input = getValue<input_ADC_IN>(ctx);
  if (input > 0.9) {
    emitValue<output_RIGHT>(ctx, false);
    emitValue<output_UP>(ctx, false);
    emitValue<output_DOWN>(ctx, false);
    emitValue<output_LEFT>(ctx, false);
    emitValue<output_SELECT>(ctx, false);
    return;
  }

  int i = 0;
  for (; i < state->num_keys; ++i) {
    if (input < state->adc_key_val[i]) {
      break;
    }
  }

  if (i >= state->num_keys) {
    i = -1;
  }

  switch (i) {
    case 0:
      emitValue<output_RIGHT>(ctx, true);
      break;
    case 1:
      emitValue<output_UP>(ctx, true);
      break;
    case 2:
      emitValue<output_DOWN>(ctx, true);
      break;
    case 3:
      emitValue<output_LEFT>(ctx, true);
      break;
    case 4:
      emitValue<output_SELECT>(ctx, true);
      break;
    default:
      break;
  }
}

} // namespace bitrex__xod_menu_system__text_lcd_16x2_keypad_impl

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/concat-menu implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__concat_menu {

//#pragma XOD dirtiness disable

namespace menu_base = ____menu_base;
using menu_base_t = menu_base::MenuBase;

/* A derived type of BiDirectionalListView, used to concatenate two
   bi-directional lists and iterate forward and backwards over both
   as a single unit. This can also be instantiated recursively. See
   e.g. the XOD standard library class "ConcatListView"*/

template <typename T>
class BiDirectionalConcatListView : public menu_base::BiDirectionalListView<T> {
 public:
  class Cursor : public menu_base::BiDirectionalCursor<T> {
   public:
     Cursor(const BiDirectionalConcatListView<T>* owner)
        : _left(std::move(owner->_left.biterate())),
          _right(std::move(owner->_right.biterate())),
          _owner(owner) {}

    bool isValid() const override { return _left && _right; }

    bool value(T* out) const override {
      return _cursor < _owner->_length_left ? _left.value(out) : _right.value(out);
    }

    void next() override {
      const auto total = _owner->_length_left + _owner->_length_right;
      if (_cursor < _owner->_length_left - 1) {
        ++_left;
      } else if (_cursor >= _owner->_length_left - 1 && _cursor < total) {
        if (_cursor != _owner->_length_left - 1) {
          ++_right;
        }
      }
      ++_cursor;
    }

    void prev() override {
      const auto total = _owner->_length_left + _owner->_length_right;
      if (_cursor > _owner->_length_left - 1 && _cursor != total - _owner->_length_right) {
        --_right;
      } else if (_cursor <= _owner->_length_left - 1) {
        --_left;
      }
      if (_cursor) {
        --_cursor;
      }
    }

   private:
    menu_base::BiDirectionalIterator<T> _left;
    menu_base::BiDirectionalIterator<T> _right;
    const BiDirectionalConcatListView<T>* _owner;
    size_t _cursor = 0;
  };

 public:
  BiDirectionalConcatListView() = default;

  BiDirectionalConcatListView(menu_base::BiDirectionalList<T> left,
                              menu_base::BiDirectionalList<T> right)
      : _left(left), _right(right), _length_left(length(left)), _length_right(length(right)) {}

  BiDirectionalConcatListView& operator=(
      const BiDirectionalConcatListView& rhs) {
    _left = rhs._left;
    _right = rhs._right;
    _length_left = rhs._length_left;
    _length_right = rhs._length_right;
    return *this;
  }

  Iterator<T> iterate() const override {
     return Iterator<T>(new Cursor(this));
  }

  menu_base::BiDirectionalIterator<T> biterate() const override {
    return menu_base::BiDirectionalIterator<T>(new Cursor(this));
  }

 private:
  friend class Cursor;
  menu_base::BiDirectionalList<T> _left;
  menu_base::BiDirectionalList<T> _right;
  size_t _length_left;
  size_t _length_right;
};

/* The state for this node contains a BiDirectionalConcatListView
   of over the two BiDirectionalLists of menu_base_t-type pointers
   it accepts as  inputs. This node is employed variadically so there
   will be an additional BiDirectionalConcatListView-containing state
   genearted for each additional input created beyond the first two. */

struct State {
    BiDirectionalConcatListView<menu_base_t*> menu_ptr_list_view;
};

struct Node {
    State state;
    bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_IN1 { };
struct input_IN2 { };
struct output_OUT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_IN1> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };
template<> struct ValueType<input_IN2> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };
template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

struct ContextObject {
    Node* _node;

    bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN1;
    bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN2;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_IN1 input_IN2" \
            " output_OUT");
}

template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN1>(Context ctx) {
    return ctx->_input_IN1;
}
template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN2>(Context ctx) {
    return ctx->_input_IN2;
}
template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT");
}

template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    if(isSettingUp()) {
        using menu_base::BiDirectionalList;
        auto state = getState(ctx);
        const auto in1 = getValue<input_IN1>(ctx);
        const auto in2 = getValue<input_IN2>(ctx);
        //create a new concat-view join the incoming lists once on startup,
        //the outputs remain static after that
        state->menu_ptr_list_view = BiDirectionalConcatListView<menu_base_t*>(in1, in2);
        //output is a list that can be further concatenated
        emitValue<output_OUT>(ctx, BiDirectionalList<menu_base_t*>(&state->menu_ptr_list_view));
    }
}

} // namespace bitrex__xod_menu_system__concat_menu

//-----------------------------------------------------------------------------
// xod/core/debounce(boolean) implementation
//-----------------------------------------------------------------------------
namespace xod__core__debounce__boolean {

struct State {
    bool state = false;
};

struct Node {
    State state;
    TimeMs timeoutAt;
    Logic output_OUT;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_ST { };
struct input_Ts { };
struct output_OUT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_ST> { using T = Logic; };
template<> struct ValueType<input_Ts> { using T = Number; };
template<> struct ValueType<output_OUT> { using T = Logic; };

struct ContextObject {
    Node* _node;

    Logic _input_ST;
    Number _input_Ts;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_ST input_Ts" \
            " output_OUT");
}

template<> Logic getValue<input_ST>(Context ctx) {
    return ctx->_input_ST;
}
template<> Number getValue<input_Ts>(Context ctx) {
    return ctx->_input_Ts;
}
template<> Logic getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT");
}

template<> void emitValue<output_OUT>(Context ctx, Logic val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    State* state = getState(ctx);
    bool x = getValue<input_ST>(ctx);

    if (x != state->state) {
        state->state = x;
        TimeMs dt = getValue<input_Ts>(ctx) * 1000;
        setTimeout(ctx, dt);
    }

    if (isTimedOut(ctx)) {
        emitValue<output_OUT>(ctx, x);
    }
}

} // namespace xod__core__debounce__boolean

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/branch-menu-item implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__branch_menu_item {

//#pragma XOD dirtiness disable

/* include the base class type of a Menu item */

namespace menu_base = ____menu_base;
using menu_base_t = menu_base::MenuBase;

/* A wrapper for a raw BiDirectionalList that allows a Branch-type
   menu to retain/manage location state when the user is paging thru its
   sub-menus */

template <typename MenuBase>
class SubMenuIterator {
  public:
   SubMenuIterator() = default;

  explicit SubMenuIterator(menu_base::BiDirectionalList<MenuBase*> sub_menus) :
                     sub_menu_ptr_list_(sub_menus), length_(xod::length(sub_menus)) {}

  menu_base::BiDirectionalList<MenuBase*> menu_ptr_list() const {
    return sub_menu_ptr_list_;
  }

  SubMenuIterator<MenuBase>& operator++() {
    if (cursor_ < length_ - 1) ++cursor_;
    return *this;
  }

  SubMenuIterator<MenuBase>& operator--() {
    if (cursor_ > 0) --cursor_;
    return *this;
  }

  MenuBase* current_menu_ptr() {
    auto it = sub_menu_ptr_list_.iterate();
    for (uint8_t i = 0; i < cursor_; ++i) { ++it; }
    return *it;
  }

  void reset() {
    cursor_ = 0;
  }

  private:
    menu_base::BiDirectionalList<MenuBase*> sub_menu_ptr_list_;
    uint8_t length_ = 0;
    uint8_t cursor_ = 0;
};

/* An interface class for a Branch-type menu page which inherits the default
   MenuInterface methods plus additional Branch-type specific methods to allow

   navigation thru its sub-menus. */

template <typename MenuBase, template <typename> class BranchMenuImpl>
class BranchMenuInterface : public menu_base::MenuInterface<MenuBase, BranchMenuImpl> {
 public:
    MenuBase* sub_menu_ptr() {
        return static_cast<BranchMenuImpl<MenuBase>*>(this)->sub_menu_ptr_();
    }

    MenuBase* next() {
        return static_cast<BranchMenuImpl<MenuBase>*>(this)->next_();
    }

    MenuBase* prev() {
        return static_cast<BranchMenuImpl<MenuBase>*>(this)->prev_();
    }

    BranchMenuImpl<MenuBase>* parent() {
        return static_cast<BranchMenuImpl<MenuBase>*>(this)->parent_();
    }

    void set_parent(BranchMenuImpl<MenuBase>* parent) {
        static_cast<BranchMenuImpl<MenuBase>*>(this)->set_parent_(parent);
    }
};

/* an implementation of a Branch-type menu page satisfying the requirements
  from the above interface. */

template <typename MenuBase>
class BranchMenuImpl final
    : public BranchMenuInterface<MenuBase, BranchMenuImpl>,
      public MenuBase {
  friend class menu_base::MenuInterface<MenuBase, BranchMenuImpl>;
  friend class BranchMenuInterface<MenuBase, BranchMenuImpl>;

 public:
  constexpr BranchMenuImpl()
      : MenuBase(0),
        menu_text_lines_view_(PlainListView<XString>(nullptr, 0)) {}

  BranchMenuImpl(menu_base::BiDirectionalList<MenuBase*> sub_menu_ptr_list,
                 XString menu_text_1, XString menu_text_2, Number user_id)
      : MenuBase(user_id),
        menu_text_({menu_text_1, menu_text_2}),
        menu_text_lines_view_(PlainListView<XString>(menu_text_, 2)),
        sub_menu_it_(SubMenuIterator<MenuBase>(sub_menu_ptr_list))
        {}

 protected:
  List<XString> text_() override {
    menu_text_lines_view_ = PlainListView<XString>(menu_text_, 2);
    return List<XString>(&menu_text_lines_view_);
  }

  MenuBase* invoke_(Number /* param */) override {
      sub_menu_it_.reset();
      return this;
  }

  MenuBase* sub_menu_ptr_() {
      return sub_menu_it_.current_menu_ptr();
  }

  MenuBase* next_() {
      ++sub_menu_it_;
      return sub_menu_it_.current_menu_ptr();
  }

  MenuBase* prev_() {
      --sub_menu_it_;
      return sub_menu_it_.current_menu_ptr();
  }

  BranchMenuImpl<MenuBase>* parent_() const {
    return parent_ptr_;
  }

  void set_parent_(BranchMenuImpl<MenuBase>* parent) {
      parent_ptr_ = parent;
  }

 private:
  XString menu_text_[2];
  PlainListView<XString> menu_text_lines_view_;
  SubMenuIterator<MenuBase> sub_menu_it_;
  BranchMenuImpl<MenuBase>* parent_ptr_ = nullptr;
};

/* The state for this node contains an instance of a Branch-type menu class
   plus a ListView, so that the node can output a List-type wrapper holding its
   pointer, so that its pointer can be appended into further lists of Menu-type
   pointers to allow automatic construction of a tree-like data structure. */

struct State {
  BranchMenuImpl<menu_base_t> branch_menu;
  menu_base_t* branch_menu_ptr;
  menu_base::BiDirectionalPlainListView<menu_base_t*> branch_menu_ptr_view =
      menu_base::BiDirectionalPlainListView<menu_base_t*>(&branch_menu_ptr, 1);
};

struct Node {
    State state;
    bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_IN { };
struct input_LINE1 { };
struct input_LINE2 { };
struct input_ID { };
struct output_OUT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_IN> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };
template<> struct ValueType<input_LINE1> { using T = XString; };
template<> struct ValueType<input_LINE2> { using T = XString; };
template<> struct ValueType<input_ID> { using T = uint8_t; };
template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

struct ContextObject {
    Node* _node;

    bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN;
    XString _input_LINE1;
    XString _input_LINE2;
    uint8_t _input_ID;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_IN input_LINE1 input_LINE2 input_ID" \
            " output_OUT");
}

template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN>(Context ctx) {
    return ctx->_input_IN;
}
template<> XString getValue<input_LINE1>(Context ctx) {
    return ctx->_input_LINE1;
}
template<> XString getValue<input_LINE2>(Context ctx) {
    return ctx->_input_LINE2;
}
template<> uint8_t getValue<input_ID>(Context ctx) {
    return ctx->_input_ID;
}
template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT");
}

template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
  if (isSettingUp()) {
    using menu_base::BiDirectionalList;
    auto state = getState(ctx);
    auto in = getValue<input_IN>(ctx);
    auto text1 = getValue<input_LINE1>(ctx);
    auto text2 = getValue<input_LINE2>(ctx);
    auto id = getValue<input_ID>(ctx);
    state->branch_menu = BranchMenuImpl<menu_base_t>(in, text1, text2, id);
    state->branch_menu_ptr = &state->branch_menu;
    emitValue<output_OUT>(ctx, menu_base::BiDirectionalList<menu_base_t*>(&state->branch_menu_ptr_view));
  }
}

} // namespace bitrex__xod_menu_system__branch_menu_item

//-----------------------------------------------------------------------------
// xod/core/pulse-on-true implementation
//-----------------------------------------------------------------------------
namespace xod__core__pulse_on_true {

struct State {
  bool state = false;
};

struct Node {
    State state;
    Logic output_OUT;

    union {
        struct {
            bool isOutputDirty_OUT : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_IN { };
struct output_OUT { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_IN> { using T = Logic; };
template<> struct ValueType<output_OUT> { using T = Logic; };

struct ContextObject {
    Node* _node;

    Logic _input_IN;

};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_IN" \
            " output_OUT");
}

template<> Logic getValue<input_IN>(Context ctx) {
    return ctx->_input_IN;
}
template<> Logic getValue<output_OUT>(Context ctx) {
    return ctx->_node->output_OUT;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            "");
    return false;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_OUT");
}

template<> void emitValue<output_OUT>(Context ctx, Logic val) {
    ctx->_node->output_OUT = val;
    ctx->_node->isOutputDirty_OUT = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void evaluate(Context ctx) {
    State* state = getState(ctx);
    auto newValue = getValue<input_IN>(ctx);

    if (newValue == true && state->state == false)
        emitValue<output_OUT>(ctx, 1);

    state->state = newValue;
}

} // namespace xod__core__pulse_on_true

//-----------------------------------------------------------------------------
// bitrex/xod-menu-system/menu-controller implementation
//-----------------------------------------------------------------------------
namespace bitrex__xod_menu_system__menu_controller {

//#pragma XOD dirtiness disable

namespace menu_base = ____menu_base;
using menu_base_t = menu_base::MenuBase;
namespace branch_menu_item = ____branch_menu_item;

/* a MenuCursor interface, providing an interface from user

   selections on a keypad to navigating thru the menu tree,

   selecting, and invoking menu items */

template <typename MenuBase>
class MenuCursor {
 public:
  MenuCursor() = default;

  explicit MenuCursor(branch_menu_item::BranchMenuImpl<MenuBase>* top_menu)
      : top_menu_ptr_(top_menu),
        current_root_menu_ptr_(nullptr),
        current_sub_menu_ptr_(top_menu) {}

  void back() {
    auto parent_ptr = current_root_menu_ptr_->parent();
    if (parent_ptr && current_sub_menu_ptr_!= top_menu_ptr_) {
      current_root_menu_ptr_ = parent_ptr;
      current_sub_menu_ptr_ = current_root_menu_ptr_->sub_menu_ptr();
    } else {
      current_sub_menu_ptr_ = top_menu_ptr_;
      current_root_menu_ptr_ = nullptr;
    }
  }

  void left() {
    if (current_root_menu_ptr_) {
      current_sub_menu_ptr_ = current_root_menu_ptr_->prev();
    }
  }

  void right() {
    if (current_root_menu_ptr_) {
      current_sub_menu_ptr_ = current_root_menu_ptr_->next();
    }
  }

  void invoke(Number param) {
    auto menu_ptr = current_sub_menu_ptr_->invoke(param);
    if (menu_ptr) {
      auto prev_root_menu_ = current_root_menu_ptr_;
      current_root_menu_ptr_ =
          static_cast<branch_menu_item::BranchMenuImpl<MenuBase>*>(
              menu_ptr);
      current_root_menu_ptr_->set_parent(prev_root_menu_);
      current_sub_menu_ptr_ = current_root_menu_ptr_->sub_menu_ptr();
    }
  }

  List<XString> text() const { return current_sub_menu_ptr_->text(); }

 private:
  branch_menu_item::BranchMenuImpl<MenuBase>* top_menu_ptr_ = nullptr;
  branch_menu_item::BranchMenuImpl<MenuBase>* current_root_menu_ptr_ = nullptr;
  MenuBase* current_sub_menu_ptr_ = nullptr;
};

/* State for this node holds a branch menu to which the rest of
   the menu structure is connected and derives from */

struct State {
  MenuCursor<menu_base_t> menu_cursor;
  branch_menu_item::BranchMenuImpl<menu_base_t> root_menu;
};

struct Node {
    State state;
    XString output_LINE1;
    XString output_LINE2;
    XString output_LINE3;
    XString output_LINE4;

    union {
        struct {
            bool isOutputDirty_LINE1 : 1;
            bool isOutputDirty_LINE2 : 1;
            bool isOutputDirty_LINE3 : 1;
            bool isOutputDirty_LINE4 : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_MENU_TREE { };
struct input_TITLE_1 { };
struct input_TITLE_2 { };
struct input_RIGHT { };
struct input_LEFT { };
struct input_BACK { };
struct input_INVOKE { };
struct input_TOP { };
struct input_PARAM_IN { };
struct output_LINE1 { };
struct output_LINE2 { };
struct output_LINE3 { };
struct output_LINE4 { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_MENU_TREE> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };
template<> struct ValueType<input_TITLE_1> { using T = XString; };
template<> struct ValueType<input_TITLE_2> { using T = XString; };
template<> struct ValueType<input_RIGHT> { using T = Logic; };
template<> struct ValueType<input_LEFT> { using T = Logic; };
template<> struct ValueType<input_BACK> { using T = Logic; };
template<> struct ValueType<input_INVOKE> { using T = Logic; };
template<> struct ValueType<input_TOP> { using T = Logic; };
template<> struct ValueType<input_PARAM_IN> { using T = Number; };
template<> struct ValueType<output_LINE1> { using T = XString; };
template<> struct ValueType<output_LINE2> { using T = XString; };
template<> struct ValueType<output_LINE3> { using T = XString; };
template<> struct ValueType<output_LINE4> { using T = XString; };

struct ContextObject {
    Node* _node;

    bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_MENU_TREE;
    XString _input_TITLE_1;
    XString _input_TITLE_2;
    Logic _input_RIGHT;
    Logic _input_LEFT;
    Logic _input_BACK;
    Logic _input_INVOKE;
    Logic _input_TOP;
    Number _input_PARAM_IN;

    bool _isInputDirty_RIGHT;
    bool _isInputDirty_LEFT;
    bool _isInputDirty_BACK;
    bool _isInputDirty_INVOKE;
    bool _isInputDirty_TOP;
};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_MENU_TREE input_TITLE_1 input_TITLE_2 input_RIGHT input_LEFT input_BACK input_INVOKE input_TOP input_PARAM_IN" \
            " output_LINE1 output_LINE2 output_LINE3 output_LINE4");
}

template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_MENU_TREE>(Context ctx) {
    return ctx->_input_MENU_TREE;
}
template<> XString getValue<input_TITLE_1>(Context ctx) {
    return ctx->_input_TITLE_1;
}
template<> XString getValue<input_TITLE_2>(Context ctx) {
    return ctx->_input_TITLE_2;
}
template<> Logic getValue<input_RIGHT>(Context ctx) {
    return ctx->_input_RIGHT;
}
template<> Logic getValue<input_LEFT>(Context ctx) {
    return ctx->_input_LEFT;
}
template<> Logic getValue<input_BACK>(Context ctx) {
    return ctx->_input_BACK;
}
template<> Logic getValue<input_INVOKE>(Context ctx) {
    return ctx->_input_INVOKE;
}
template<> Logic getValue<input_TOP>(Context ctx) {
    return ctx->_input_TOP;
}
template<> Number getValue<input_PARAM_IN>(Context ctx) {
    return ctx->_input_PARAM_IN;
}
template<> XString getValue<output_LINE1>(Context ctx) {
    return ctx->_node->output_LINE1;
}
template<> XString getValue<output_LINE2>(Context ctx) {
    return ctx->_node->output_LINE2;
}
template<> XString getValue<output_LINE3>(Context ctx) {
    return ctx->_node->output_LINE3;
}
template<> XString getValue<output_LINE4>(Context ctx) {
    return ctx->_node->output_LINE4;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            " input_RIGHT input_LEFT input_BACK input_INVOKE input_TOP");
    return false;
}

template<> bool isInputDirty<input_RIGHT>(Context ctx) {
    return ctx->_isInputDirty_RIGHT;
}
template<> bool isInputDirty<input_LEFT>(Context ctx) {
    return ctx->_isInputDirty_LEFT;
}
template<> bool isInputDirty<input_BACK>(Context ctx) {
    return ctx->_isInputDirty_BACK;
}
template<> bool isInputDirty<input_INVOKE>(Context ctx) {
    return ctx->_isInputDirty_INVOKE;
}
template<> bool isInputDirty<input_TOP>(Context ctx) {
    return ctx->_isInputDirty_TOP;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_LINE1 output_LINE2 output_LINE3 output_LINE4");
}

template<> void emitValue<output_LINE1>(Context ctx, XString val) {
    ctx->_node->output_LINE1 = val;
    ctx->_node->isOutputDirty_LINE1 = true;
}
template<> void emitValue<output_LINE2>(Context ctx, XString val) {
    ctx->_node->output_LINE2 = val;
    ctx->_node->isOutputDirty_LINE2 = true;
}
template<> void emitValue<output_LINE3>(Context ctx, XString val) {
    ctx->_node->output_LINE3 = val;
    ctx->_node->isOutputDirty_LINE3 = true;
}
template<> void emitValue<output_LINE4>(Context ctx, XString val) {
    ctx->_node->output_LINE4 = val;
    ctx->_node->isOutputDirty_LINE4 = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

static XStringCString null_string = XStringCString("");

void evaluate(Context ctx) {
  auto state = getState(ctx);

  if (isSettingUp()) {
    auto title_1 = getValue<input_TITLE_1>(ctx);
    auto title_2 = getValue<input_TITLE_2>(ctx);
    state->root_menu =
    branch_menu_item::BranchMenuImpl<menu_base_t>(getValue<input_MENU_TREE>(ctx), title_1,
                                                  title_2, 0);
    state->root_menu.set_parent(&state->root_menu);
    state->menu_cursor = MenuCursor<menu_base_t>(&state->root_menu);
  }

 /* update all trigger pulse inputs */

  bool back = isInputDirty<input_BACK>(ctx);
  bool left = isInputDirty<input_LEFT>(ctx);
  bool right = isInputDirty<input_RIGHT>(ctx);
  bool invoke = isInputDirty<input_INVOKE>(ctx);

  if (back) {
    state->menu_cursor.back();
  }
  if (left) {
    state->menu_cursor.left();
  }
  if (right) {
    state->menu_cursor.right();
  }
  if (invoke) {
    // if a menu is invoked pass along the input parameter
    // to the appropriate MenuBase class instance
    auto param = getValue<input_PARAM_IN>(ctx);
    state->menu_cursor.invoke(param);
  }

  //Update the menu dispaly text

  auto text_list = state->menu_cursor.text();
  auto text_it = text_list.iterate();
  emitValue<output_LINE1>(ctx, *text_it);

  if (++text_it) {
    emitValue<output_LINE2>(ctx, *text_it);
  } else {
    emitValue<output_LINE2>(ctx, null_string);
    return;
  }
  if (++text_it) {
    emitValue<output_LINE3>(ctx, *text_it);
  } else {
    emitValue<output_LINE3>(ctx, null_string);
    return;
  }
  if (++text_it) {
    emitValue<output_LINE4>(ctx, *text_it);
  } else {
    emitValue<output_LINE4>(ctx, null_string);
    return;
  }
}

} // namespace bitrex__xod_menu_system__menu_controller

//-----------------------------------------------------------------------------
// xod/common-hardware/text-lcd-16x2 implementation
//-----------------------------------------------------------------------------
namespace xod__common_hardware__text_lcd_16x2 {

// --- Enter global namespace ---
}}
#include <LiquidCrystal.h>

namespace xod {
namespace xod__common_hardware__text_lcd_16x2 {
// --- Back to local namespace ---
struct State {
    LiquidCrystal* lcd;
};

struct Node {
    State state;
    Logic output_DONE;

    union {
        struct {
            bool isOutputDirty_DONE : 1;
            bool isNodeDirty : 1;
        };

        DirtyFlags dirtyFlags;
    };
};

struct input_RS { };
struct input_EN { };
struct input_D4 { };
struct input_D5 { };
struct input_D6 { };
struct input_D7 { };
struct input_L1 { };
struct input_L2 { };
struct input_UPD { };
struct output_DONE { };

template<typename PinT> struct ValueType { using T = void; };
template<> struct ValueType<input_RS> { using T = uint8_t; };
template<> struct ValueType<input_EN> { using T = uint8_t; };
template<> struct ValueType<input_D4> { using T = uint8_t; };
template<> struct ValueType<input_D5> { using T = uint8_t; };
template<> struct ValueType<input_D6> { using T = uint8_t; };
template<> struct ValueType<input_D7> { using T = uint8_t; };
template<> struct ValueType<input_L1> { using T = XString; };
template<> struct ValueType<input_L2> { using T = XString; };
template<> struct ValueType<input_UPD> { using T = Logic; };
template<> struct ValueType<output_DONE> { using T = Logic; };

struct ContextObject {
    Node* _node;

    uint8_t _input_RS;
    uint8_t _input_EN;
    uint8_t _input_D4;
    uint8_t _input_D5;
    uint8_t _input_D6;
    uint8_t _input_D7;
    XString _input_L1;
    XString _input_L2;
    Logic _input_UPD;

    bool _isInputDirty_UPD;
};

using Context = ContextObject*;

template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {
    static_assert(always_false<PinT>::value,
            "Invalid pin descriptor. Expected one of:" \
            " input_RS input_EN input_D4 input_D5 input_D6 input_D7 input_L1 input_L2 input_UPD" \
            " output_DONE");
}

template<> uint8_t getValue<input_RS>(Context ctx) {
    return ctx->_input_RS;
}
template<> uint8_t getValue<input_EN>(Context ctx) {
    return ctx->_input_EN;
}
template<> uint8_t getValue<input_D4>(Context ctx) {
    return ctx->_input_D4;
}
template<> uint8_t getValue<input_D5>(Context ctx) {
    return ctx->_input_D5;
}
template<> uint8_t getValue<input_D6>(Context ctx) {
    return ctx->_input_D6;
}
template<> uint8_t getValue<input_D7>(Context ctx) {
    return ctx->_input_D7;
}
template<> XString getValue<input_L1>(Context ctx) {
    return ctx->_input_L1;
}
template<> XString getValue<input_L2>(Context ctx) {
    return ctx->_input_L2;
}
template<> Logic getValue<input_UPD>(Context ctx) {
    return ctx->_input_UPD;
}
template<> Logic getValue<output_DONE>(Context ctx) {
    return ctx->_node->output_DONE;
}

template<typename InputT> bool isInputDirty(Context ctx) {
    static_assert(always_false<InputT>::value,
            "Invalid input descriptor. Expected one of:" \
            " input_UPD");
    return false;
}

template<> bool isInputDirty<input_UPD>(Context ctx) {
    return ctx->_isInputDirty_UPD;
}

template<typename OutputT> void emitValue(Context ctx, typename ValueType<OutputT>::T val) {
    static_assert(always_false<OutputT>::value,
            "Invalid output descriptor. Expected one of:" \
            " output_DONE");
}

template<> void emitValue<output_DONE>(Context ctx, Logic val) {
    ctx->_node->output_DONE = val;
    ctx->_node->isOutputDirty_DONE = true;
}

State* getState(Context ctx) {
    return &ctx->_node->state;
}

void printLine(LiquidCrystal* lcd, uint8_t lineIndex, XString str) {
    lcd->setCursor(0, lineIndex);
    uint8_t whitespace = 16;
    for (auto it = str->iterate(); it; ++it, --whitespace)
        lcd->write(*it);

    // Clear the rest of the line
    while (whitespace--)
        lcd->write(' ');
}

void evaluate(Context ctx) {
    if (!isInputDirty<input_UPD>(ctx))
        return;

    State* state = getState(ctx);
    auto lcd = state->lcd;
    if (!state->lcd) {
        state->lcd = lcd = new LiquidCrystal(
            (int)getValue<input_RS>(ctx),
            (int)getValue<input_EN>(ctx),
            (int)getValue<input_D4>(ctx),
            (int)getValue<input_D5>(ctx),
            (int)getValue<input_D6>(ctx),
            (int)getValue<input_D7>(ctx));

        lcd->begin(16, 2);
    }

    printLine(lcd, 0, getValue<input_L1>(ctx));
    printLine(lcd, 1, getValue<input_L2>(ctx));

    emitValue<output_DONE>(ctx, 1);
}

} // namespace xod__common_hardware__text_lcd_16x2

} // namespace xod


/*=============================================================================
 *
 *
 * Main loop components
 *
 *
 =============================================================================*/

namespace xod {

// Define/allocate persistent storages (state, timeout, output data) for all nodes
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"

constexpr XString node_0_output_TXT = XString();

constexpr XString node_1_output_TXT = XString();

constexpr XString node_2_output_TXT = XString();

constexpr bitrex__xod_menu_system__menu_base::Type node_3_output_OUT = { /* bitrex/xod-menu-system/menu-base */ };

constexpr XString node_4_output_TXT = XString();

constexpr bitrex__xod_menu_system__menu_base::Type node_5_output_OUT = { /* bitrex/xod-menu-system/menu-base */ };

constexpr Number node_6_output_VAL = 0;

constexpr XString node_7_output_VAL = XString();

constexpr uint8_t node_8_output_VAL = 0x0;

constexpr uint8_t node_9_output_VAL = A0;

constexpr Number node_10_output_VAL = 0.03;

constexpr Number node_11_output_VAL = 0.03;

constexpr Number node_12_output_VAL = 0.03;

constexpr Number node_13_output_VAL = 0.03;

constexpr Number node_14_output_VAL = 0.03;

constexpr XString node_15_output_VAL = XString();

constexpr XString node_16_output_VAL = XString();

constexpr uint8_t node_17_output_VAL = 0x0;

constexpr uint8_t node_18_output_VAL = 0;

constexpr uint8_t node_19_output_VAL = 0;

constexpr uint8_t node_20_output_VAL = 0;

constexpr uint8_t node_21_output_VAL = 0;

constexpr uint8_t node_22_output_VAL = 0;

constexpr uint8_t node_23_output_VAL = 0;

constexpr XString node_24_output_VAL = XString();

constexpr uint8_t node_25_output_VAL = 0x0;

constexpr XString node_26_output_VAL = XString();

constexpr XString node_27_output_VAL = XString();

constexpr uint8_t node_28_output_VAL = 0x0;

constexpr Logic node_29_output_TICK = false;

constexpr bitrex__xod_menu_system__menu_base::Type node_30_output_OUT = { /* bitrex/xod-menu-system/menu-base */ };

constexpr XString node_31_output_VAL = XString();

constexpr XString node_32_output_VAL = XString();

constexpr uint8_t node_33_output_VAL = 0x0;

constexpr bitrex__xod_menu_system__menu_base::Type node_34_output_OUT = { /* bitrex/xod-menu-system/menu-base */ };

constexpr XString node_35_output_VAL = XString();

constexpr XString node_36_output_VAL = XString();

constexpr uint8_t node_37_output_VAL = 0x0;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_38_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };
constexpr Number node_38_output_PARAM = 0;
constexpr Logic node_38_output_INVOKED = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_39_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };
constexpr Number node_39_output_PARAM = 0;
constexpr Logic node_39_output_INVOKED = false;

constexpr Number node_40_output_VAL = 0;
constexpr Logic node_40_output_DONE = false;
constexpr Logic node_40_output_ERR = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_41_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };
constexpr Number node_41_output_PARAM = 0;
constexpr Logic node_41_output_INVOKED = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_42_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };
constexpr Number node_42_output_PARAM = 0;
constexpr Logic node_42_output_INVOKED = false;

constexpr Logic node_43_output_RIGHT = false;
constexpr Logic node_43_output_LEFT = false;
constexpr Logic node_43_output_UP = false;
constexpr Logic node_43_output_DOWN = false;
constexpr Logic node_43_output_SELECT = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_44_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_45_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

constexpr Logic node_46_output_OUT = false;

constexpr Logic node_47_output_OUT = false;

constexpr Logic node_48_output_OUT = false;

constexpr Logic node_49_output_OUT = false;

constexpr Logic node_50_output_OUT = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_51_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_52_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

constexpr Logic node_53_output_OUT = false;

constexpr Logic node_54_output_OUT = false;

constexpr Logic node_55_output_OUT = false;

constexpr Logic node_56_output_OUT = false;

constexpr Logic node_57_output_OUT = false;

constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_58_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

constexpr XString node_59_output_LINE1 = XString();
constexpr XString node_59_output_LINE2 = XString();
constexpr XString node_59_output_LINE3 = XString();
constexpr XString node_59_output_LINE4 = XString();

constexpr Logic node_60_output_DONE = false;

#pragma GCC diagnostic pop

bitrex__xod_menu_system__flash_string_1::Node node_0 = {
    bitrex__xod_menu_system__flash_string_1::State(), // state default
    node_0_output_TXT, // output TXT default
    true, // TXT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__flash_string_1::Node node_1 = {
    bitrex__xod_menu_system__flash_string_1::State(), // state default
    node_1_output_TXT, // output TXT default
    true, // TXT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__flash_string_1::Node node_2 = {
    bitrex__xod_menu_system__flash_string_1::State(), // state default
    node_2_output_TXT, // output TXT default
    true, // TXT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__menu_base::Node node_3 = {
    bitrex__xod_menu_system__menu_base::State(), // state default
    node_3_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__flash_string_1::Node node_4 = {
    bitrex__xod_menu_system__flash_string_1::State(), // state default
    node_4_output_TXT, // output TXT default
    true, // TXT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__menu_base::Node node_5 = {
    bitrex__xod_menu_system__menu_base::State(), // state default
    node_5_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__continuously::Node node_29 = {
    xod__core__continuously::State(), // state default
    0, // timeoutAt
    node_29_output_TICK, // output TICK default
    false, // TICK dirty
    true // node itself dirty
};
bitrex__xod_menu_system__menu_base::Node node_30 = {
    bitrex__xod_menu_system__menu_base::State(), // state default
    node_30_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__menu_base::Node node_34 = {
    bitrex__xod_menu_system__menu_base::State(), // state default
    node_34_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__leaf_menu_item_impl::Node node_38 = {
    bitrex__xod_menu_system__leaf_menu_item_impl::State(), // state default
    0, // timeoutAt
    node_38_output_OUT, // output OUT default
    node_38_output_PARAM, // output PARAM default
    node_38_output_INVOKED, // output INVOKED default
    true, // OUT dirty
    true, // PARAM dirty
    false, // INVOKED dirty
    true // node itself dirty
};
bitrex__xod_menu_system__leaf_menu_item_impl::Node node_39 = {
    bitrex__xod_menu_system__leaf_menu_item_impl::State(), // state default
    0, // timeoutAt
    node_39_output_OUT, // output OUT default
    node_39_output_PARAM, // output PARAM default
    node_39_output_INVOKED, // output INVOKED default
    true, // OUT dirty
    true, // PARAM dirty
    false, // INVOKED dirty
    true // node itself dirty
};
xod__gpio__analog_read::Node node_40 = {
    xod__gpio__analog_read::State(), // state default
    node_40_output_VAL, // output VAL default
    node_40_output_DONE, // output DONE default
    node_40_output_ERR, // output ERR default
    true, // VAL dirty
    false, // DONE dirty
    false, // ERR dirty
    true // node itself dirty
};
bitrex__xod_menu_system__leaf_menu_item_impl::Node node_41 = {
    bitrex__xod_menu_system__leaf_menu_item_impl::State(), // state default
    0, // timeoutAt
    node_41_output_OUT, // output OUT default
    node_41_output_PARAM, // output PARAM default
    node_41_output_INVOKED, // output INVOKED default
    true, // OUT dirty
    true, // PARAM dirty
    false, // INVOKED dirty
    true // node itself dirty
};
bitrex__xod_menu_system__leaf_menu_item_impl::Node node_42 = {
    bitrex__xod_menu_system__leaf_menu_item_impl::State(), // state default
    0, // timeoutAt
    node_42_output_OUT, // output OUT default
    node_42_output_PARAM, // output PARAM default
    node_42_output_INVOKED, // output INVOKED default
    true, // OUT dirty
    true, // PARAM dirty
    false, // INVOKED dirty
    true // node itself dirty
};
bitrex__xod_menu_system__text_lcd_16x2_keypad_impl::Node node_43 = {
    bitrex__xod_menu_system__text_lcd_16x2_keypad_impl::State(), // state default
    node_43_output_RIGHT, // output RIGHT default
    node_43_output_LEFT, // output LEFT default
    node_43_output_UP, // output UP default
    node_43_output_DOWN, // output DOWN default
    node_43_output_SELECT, // output SELECT default
    true, // RIGHT dirty
    true, // LEFT dirty
    true, // UP dirty
    true, // DOWN dirty
    true, // SELECT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__concat_menu::Node node_44 = {
    bitrex__xod_menu_system__concat_menu::State(), // state default
    node_44_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__concat_menu::Node node_45 = {
    bitrex__xod_menu_system__concat_menu::State(), // state default
    node_45_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__debounce__boolean::Node node_46 = {
    xod__core__debounce__boolean::State(), // state default
    0, // timeoutAt
    node_46_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__debounce__boolean::Node node_47 = {
    xod__core__debounce__boolean::State(), // state default
    0, // timeoutAt
    node_47_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__debounce__boolean::Node node_48 = {
    xod__core__debounce__boolean::State(), // state default
    0, // timeoutAt
    node_48_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__debounce__boolean::Node node_49 = {
    xod__core__debounce__boolean::State(), // state default
    0, // timeoutAt
    node_49_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__debounce__boolean::Node node_50 = {
    xod__core__debounce__boolean::State(), // state default
    0, // timeoutAt
    node_50_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__branch_menu_item::Node node_51 = {
    bitrex__xod_menu_system__branch_menu_item::State(), // state default
    node_51_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__branch_menu_item::Node node_52 = {
    bitrex__xod_menu_system__branch_menu_item::State(), // state default
    node_52_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
xod__core__pulse_on_true::Node node_53 = {
    xod__core__pulse_on_true::State(), // state default
    node_53_output_OUT, // output OUT default
    false, // OUT dirty
    true // node itself dirty
};
xod__core__pulse_on_true::Node node_54 = {
    xod__core__pulse_on_true::State(), // state default
    node_54_output_OUT, // output OUT default
    false, // OUT dirty
    true // node itself dirty
};
xod__core__pulse_on_true::Node node_55 = {
    xod__core__pulse_on_true::State(), // state default
    node_55_output_OUT, // output OUT default
    false, // OUT dirty
    true // node itself dirty
};
xod__core__pulse_on_true::Node node_56 = {
    xod__core__pulse_on_true::State(), // state default
    node_56_output_OUT, // output OUT default
    false, // OUT dirty
    true // node itself dirty
};
xod__core__pulse_on_true::Node node_57 = {
    xod__core__pulse_on_true::State(), // state default
    node_57_output_OUT, // output OUT default
    false, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__concat_menu::Node node_58 = {
    bitrex__xod_menu_system__concat_menu::State(), // state default
    node_58_output_OUT, // output OUT default
    true, // OUT dirty
    true // node itself dirty
};
bitrex__xod_menu_system__menu_controller::Node node_59 = {
    bitrex__xod_menu_system__menu_controller::State(), // state default
    node_59_output_LINE1, // output LINE1 default
    node_59_output_LINE2, // output LINE2 default
    node_59_output_LINE3, // output LINE3 default
    node_59_output_LINE4, // output LINE4 default
    true, // LINE1 dirty
    true, // LINE2 dirty
    true, // LINE3 dirty
    true, // LINE4 dirty
    true // node itself dirty
};
xod__common_hardware__text_lcd_16x2::Node node_60 = {
    xod__common_hardware__text_lcd_16x2::State(), // state default
    node_60_output_DONE, // output DONE default
    false, // DONE dirty
    true // node itself dirty
};

#if defined(XOD_DEBUG) || defined(XOD_SIMULATION)
namespace detail {
void handleTweaks() {
    if (XOD_DEBUG_SERIAL.available() > 0 && XOD_DEBUG_SERIAL.find("+XOD:", 5)) {
        int tweakedNodeId = XOD_DEBUG_SERIAL.parseInt();

        switch (tweakedNodeId) {
        }

        XOD_DEBUG_SERIAL.find('\n');
    }
}
} // namespace detail
#endif

void runTransaction() {
    g_transactionTime = millis();

    XOD_TRACE_F("Transaction started, t=");
    XOD_TRACE_LN(g_transactionTime);

#if defined(XOD_DEBUG) || defined(XOD_SIMULATION)
    detail::handleTweaks();
#endif

    // Check for timeouts
    detail::checkTriggerTimeout(&node_29);
    detail::checkTriggerTimeout(&node_38);
    detail::checkTriggerTimeout(&node_39);
    detail::checkTriggerTimeout(&node_41);
    detail::checkTriggerTimeout(&node_42);
    detail::checkTriggerTimeout(&node_46);
    detail::checkTriggerTimeout(&node_47);
    detail::checkTriggerTimeout(&node_48);
    detail::checkTriggerTimeout(&node_49);
    detail::checkTriggerTimeout(&node_50);

    // defer-* nodes are always at the very bottom of the graph, so no one will
    // recieve values emitted by them. We must evaluate them before everybody
    // else to give them a chance to emit values.
    //
    // If trigerred, keep only output dirty, not the node itself, so it will
    // evaluate on the regular pass only if it pushed a new value again.

    // Evaluate all dirty nodes
    { // bitrex__xod_menu_system__flash_string_1 #0
        if (node_0.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(0);

            bitrex__xod_menu_system__flash_string_1::ContextObject ctxObj;
            ctxObj._node = &node_0;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__flash_string_1::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_59.isNodeDirty |= node_0.isOutputDirty_TXT;
        }
    }
    { // bitrex__xod_menu_system__flash_string_1 #1
        if (node_1.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(1);

            bitrex__xod_menu_system__flash_string_1::ContextObject ctxObj;
            ctxObj._node = &node_1;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__flash_string_1::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_52.isNodeDirty |= node_1.isOutputDirty_TXT;
        }
    }
    { // bitrex__xod_menu_system__flash_string_1 #2
        if (node_2.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(2);

            bitrex__xod_menu_system__flash_string_1::ContextObject ctxObj;
            ctxObj._node = &node_2;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__flash_string_1::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_59.isNodeDirty |= node_2.isOutputDirty_TXT;
        }
    }
    { // bitrex__xod_menu_system__menu_base #3
        if (node_3.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(3);

            bitrex__xod_menu_system__menu_base::ContextObject ctxObj;
            ctxObj._node = &node_3;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__menu_base::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_38.isNodeDirty |= node_3.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__flash_string_1 #4
        if (node_4.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(4);

            bitrex__xod_menu_system__flash_string_1::ContextObject ctxObj;
            ctxObj._node = &node_4;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__flash_string_1::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_51.isNodeDirty |= node_4.isOutputDirty_TXT;
        }
    }
    { // bitrex__xod_menu_system__menu_base #5
        if (node_5.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(5);

            bitrex__xod_menu_system__menu_base::ContextObject ctxObj;
            ctxObj._node = &node_5;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__menu_base::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_39.isNodeDirty |= node_5.isOutputDirty_OUT;
        }
    }
    { // xod__core__continuously #29
        if (node_29.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(29);

            xod__core__continuously::ContextObject ctxObj;
            ctxObj._node = &node_29;

            // copy data from upstream nodes into context

            xod__core__continuously::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_40.isNodeDirty |= node_29.isOutputDirty_TICK;
            node_60.isNodeDirty |= node_29.isOutputDirty_TICK;
        }
    }
    { // bitrex__xod_menu_system__menu_base #30
        if (node_30.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(30);

            bitrex__xod_menu_system__menu_base::ContextObject ctxObj;
            ctxObj._node = &node_30;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__menu_base::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_41.isNodeDirty |= node_30.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__menu_base #34
        if (node_34.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(34);

            bitrex__xod_menu_system__menu_base::ContextObject ctxObj;
            ctxObj._node = &node_34;

            // copy data from upstream nodes into context

            bitrex__xod_menu_system__menu_base::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_42.isNodeDirty |= node_34.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__leaf_menu_item_impl #38
        if (node_38.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(38);

            bitrex__xod_menu_system__leaf_menu_item_impl::ContextObject ctxObj;
            ctxObj._node = &node_38;

            // copy data from upstream nodes into context
            ctxObj._input_MENU_PTR = node_3.output_OUT;
            ctxObj._input_LINE1 = node_15_output_VAL;
            ctxObj._input_LINE2 = node_16_output_VAL;
            ctxObj._input_ID = node_17_output_VAL;

            bitrex__xod_menu_system__leaf_menu_item_impl::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_45.isNodeDirty |= node_38.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__leaf_menu_item_impl #39
        if (node_39.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(39);

            bitrex__xod_menu_system__leaf_menu_item_impl::ContextObject ctxObj;
            ctxObj._node = &node_39;

            // copy data from upstream nodes into context
            ctxObj._input_MENU_PTR = node_5.output_OUT;
            ctxObj._input_LINE1 = node_26_output_VAL;
            ctxObj._input_LINE2 = node_27_output_VAL;
            ctxObj._input_ID = node_28_output_VAL;

            bitrex__xod_menu_system__leaf_menu_item_impl::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_44.isNodeDirty |= node_39.isOutputDirty_OUT;
        }
    }
    { // xod__gpio__analog_read #40
        if (node_40.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(40);

            xod__gpio__analog_read::ContextObject ctxObj;
            ctxObj._node = &node_40;

            // copy data from upstream nodes into context
            ctxObj._input_PORT = node_9_output_VAL;
            ctxObj._input_UPD = node_29.output_TICK;

            ctxObj._isInputDirty_UPD = node_29.isOutputDirty_TICK;

            xod__gpio__analog_read::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_43.isNodeDirty |= node_40.isOutputDirty_VAL;
        }
    }
    { // bitrex__xod_menu_system__leaf_menu_item_impl #41
        if (node_41.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(41);

            bitrex__xod_menu_system__leaf_menu_item_impl::ContextObject ctxObj;
            ctxObj._node = &node_41;

            // copy data from upstream nodes into context
            ctxObj._input_MENU_PTR = node_30.output_OUT;
            ctxObj._input_LINE1 = node_31_output_VAL;
            ctxObj._input_LINE2 = node_32_output_VAL;
            ctxObj._input_ID = node_33_output_VAL;

            bitrex__xod_menu_system__leaf_menu_item_impl::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_44.isNodeDirty |= node_41.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__leaf_menu_item_impl #42
        if (node_42.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(42);

            bitrex__xod_menu_system__leaf_menu_item_impl::ContextObject ctxObj;
            ctxObj._node = &node_42;

            // copy data from upstream nodes into context
            ctxObj._input_MENU_PTR = node_34.output_OUT;
            ctxObj._input_LINE1 = node_35_output_VAL;
            ctxObj._input_LINE2 = node_36_output_VAL;
            ctxObj._input_ID = node_37_output_VAL;

            bitrex__xod_menu_system__leaf_menu_item_impl::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_45.isNodeDirty |= node_42.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__text_lcd_16x2_keypad_impl #43
        if (node_43.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(43);

            bitrex__xod_menu_system__text_lcd_16x2_keypad_impl::ContextObject ctxObj;
            ctxObj._node = &node_43;

            // copy data from upstream nodes into context
            ctxObj._input_ADC_IN = node_40.output_VAL;

            bitrex__xod_menu_system__text_lcd_16x2_keypad_impl::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_46.isNodeDirty |= node_43.isOutputDirty_RIGHT;
            node_50.isNodeDirty |= node_43.isOutputDirty_LEFT;
            node_49.isNodeDirty |= node_43.isOutputDirty_UP;
            node_47.isNodeDirty |= node_43.isOutputDirty_DOWN;
            node_48.isNodeDirty |= node_43.isOutputDirty_SELECT;
        }
    }
    { // bitrex__xod_menu_system__concat_menu #44
        if (node_44.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(44);

            bitrex__xod_menu_system__concat_menu::ContextObject ctxObj;
            ctxObj._node = &node_44;

            // copy data from upstream nodes into context
            ctxObj._input_IN1 = node_39.output_OUT;
            ctxObj._input_IN2 = node_41.output_OUT;

            bitrex__xod_menu_system__concat_menu::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_51.isNodeDirty |= node_44.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__concat_menu #45
        if (node_45.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(45);

            bitrex__xod_menu_system__concat_menu::ContextObject ctxObj;
            ctxObj._node = &node_45;

            // copy data from upstream nodes into context
            ctxObj._input_IN1 = node_38.output_OUT;
            ctxObj._input_IN2 = node_42.output_OUT;

            bitrex__xod_menu_system__concat_menu::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_52.isNodeDirty |= node_45.isOutputDirty_OUT;
        }
    }
    { // xod__core__debounce__boolean #46
        if (node_46.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(46);

            xod__core__debounce__boolean::ContextObject ctxObj;
            ctxObj._node = &node_46;

            // copy data from upstream nodes into context
            ctxObj._input_ST = node_43.output_RIGHT;
            ctxObj._input_Ts = node_10_output_VAL;

            xod__core__debounce__boolean::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_53.isNodeDirty |= node_46.isOutputDirty_OUT;
        }
    }
    { // xod__core__debounce__boolean #47
        if (node_47.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(47);

            xod__core__debounce__boolean::ContextObject ctxObj;
            ctxObj._node = &node_47;

            // copy data from upstream nodes into context
            ctxObj._input_ST = node_43.output_DOWN;
            ctxObj._input_Ts = node_11_output_VAL;

            xod__core__debounce__boolean::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_54.isNodeDirty |= node_47.isOutputDirty_OUT;
        }
    }
    { // xod__core__debounce__boolean #48
        if (node_48.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(48);

            xod__core__debounce__boolean::ContextObject ctxObj;
            ctxObj._node = &node_48;

            // copy data from upstream nodes into context
            ctxObj._input_ST = node_43.output_SELECT;
            ctxObj._input_Ts = node_12_output_VAL;

            xod__core__debounce__boolean::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_55.isNodeDirty |= node_48.isOutputDirty_OUT;
        }
    }
    { // xod__core__debounce__boolean #49
        if (node_49.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(49);

            xod__core__debounce__boolean::ContextObject ctxObj;
            ctxObj._node = &node_49;

            // copy data from upstream nodes into context
            ctxObj._input_ST = node_43.output_UP;
            ctxObj._input_Ts = node_13_output_VAL;

            xod__core__debounce__boolean::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_56.isNodeDirty |= node_49.isOutputDirty_OUT;
        }
    }
    { // xod__core__debounce__boolean #50
        if (node_50.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(50);

            xod__core__debounce__boolean::ContextObject ctxObj;
            ctxObj._node = &node_50;

            // copy data from upstream nodes into context
            ctxObj._input_ST = node_43.output_LEFT;
            ctxObj._input_Ts = node_14_output_VAL;

            xod__core__debounce__boolean::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_57.isNodeDirty |= node_50.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__branch_menu_item #51
        if (node_51.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(51);

            bitrex__xod_menu_system__branch_menu_item::ContextObject ctxObj;
            ctxObj._node = &node_51;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_44.output_OUT;
            ctxObj._input_LINE1 = node_4.output_TXT;
            ctxObj._input_LINE2 = node_7_output_VAL;
            ctxObj._input_ID = node_8_output_VAL;

            bitrex__xod_menu_system__branch_menu_item::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_58.isNodeDirty |= node_51.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__branch_menu_item #52
        if (node_52.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(52);

            bitrex__xod_menu_system__branch_menu_item::ContextObject ctxObj;
            ctxObj._node = &node_52;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_45.output_OUT;
            ctxObj._input_LINE1 = node_1.output_TXT;
            ctxObj._input_LINE2 = node_24_output_VAL;
            ctxObj._input_ID = node_25_output_VAL;

            bitrex__xod_menu_system__branch_menu_item::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_58.isNodeDirty |= node_52.isOutputDirty_OUT;
        }
    }
    { // xod__core__pulse_on_true #53
        if (node_53.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(53);

            xod__core__pulse_on_true::ContextObject ctxObj;
            ctxObj._node = &node_53;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_46.output_OUT;

            xod__core__pulse_on_true::evaluate(&ctxObj);

            // mark downstream nodes dirty
        }
    }
    { // xod__core__pulse_on_true #54
        if (node_54.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(54);

            xod__core__pulse_on_true::ContextObject ctxObj;
            ctxObj._node = &node_54;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_47.output_OUT;

            xod__core__pulse_on_true::evaluate(&ctxObj);

            // mark downstream nodes dirty
        }
    }
    { // xod__core__pulse_on_true #55
        if (node_55.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(55);

            xod__core__pulse_on_true::ContextObject ctxObj;
            ctxObj._node = &node_55;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_48.output_OUT;

            xod__core__pulse_on_true::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_59.isNodeDirty |= node_55.isOutputDirty_OUT;
        }
    }
    { // xod__core__pulse_on_true #56
        if (node_56.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(56);

            xod__core__pulse_on_true::ContextObject ctxObj;
            ctxObj._node = &node_56;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_49.output_OUT;

            xod__core__pulse_on_true::evaluate(&ctxObj);

            // mark downstream nodes dirty
        }
    }
    { // xod__core__pulse_on_true #57
        if (node_57.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(57);

            xod__core__pulse_on_true::ContextObject ctxObj;
            ctxObj._node = &node_57;

            // copy data from upstream nodes into context
            ctxObj._input_IN = node_50.output_OUT;

            xod__core__pulse_on_true::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_59.isNodeDirty |= node_57.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__concat_menu #58
        if (node_58.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(58);

            bitrex__xod_menu_system__concat_menu::ContextObject ctxObj;
            ctxObj._node = &node_58;

            // copy data from upstream nodes into context
            ctxObj._input_IN1 = node_51.output_OUT;
            ctxObj._input_IN2 = node_52.output_OUT;

            bitrex__xod_menu_system__concat_menu::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_59.isNodeDirty |= node_58.isOutputDirty_OUT;
        }
    }
    { // bitrex__xod_menu_system__menu_controller #59
        if (node_59.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(59);

            bitrex__xod_menu_system__menu_controller::ContextObject ctxObj;
            ctxObj._node = &node_59;

            // copy data from upstream nodes into context
            ctxObj._input_MENU_TREE = node_58.output_OUT;
            ctxObj._input_TITLE_1 = node_0.output_TXT;
            ctxObj._input_TITLE_2 = node_2.output_TXT;
            ctxObj._input_BACK = node_57.output_OUT;
            ctxObj._input_INVOKE = node_55.output_OUT;
            ctxObj._input_PARAM_IN = node_6_output_VAL;

            ctxObj._isInputDirty_RIGHT = false;
            ctxObj._isInputDirty_LEFT = false;
            ctxObj._isInputDirty_TOP = false;
            ctxObj._isInputDirty_BACK = node_57.isOutputDirty_OUT;
            ctxObj._isInputDirty_INVOKE = node_55.isOutputDirty_OUT;

            bitrex__xod_menu_system__menu_controller::evaluate(&ctxObj);

            // mark downstream nodes dirty
            node_60.isNodeDirty |= node_59.isOutputDirty_LINE1;
            node_60.isNodeDirty |= node_59.isOutputDirty_LINE2;
        }
    }
    { // xod__common_hardware__text_lcd_16x2 #60
        if (node_60.isNodeDirty) {
            XOD_TRACE_F("Eval node #");
            XOD_TRACE_LN(60);

            xod__common_hardware__text_lcd_16x2::ContextObject ctxObj;
            ctxObj._node = &node_60;

            // copy data from upstream nodes into context
            ctxObj._input_RS = node_18_output_VAL;
            ctxObj._input_EN = node_19_output_VAL;
            ctxObj._input_D4 = node_20_output_VAL;
            ctxObj._input_D5 = node_21_output_VAL;
            ctxObj._input_D6 = node_22_output_VAL;
            ctxObj._input_D7 = node_23_output_VAL;
            ctxObj._input_L1 = node_59.output_LINE1;
            ctxObj._input_L2 = node_59.output_LINE2;
            ctxObj._input_UPD = node_29.output_TICK;

            ctxObj._isInputDirty_UPD = node_29.isOutputDirty_TICK;

            xod__common_hardware__text_lcd_16x2::evaluate(&ctxObj);

            // mark downstream nodes dirty
        }
    }

    // Clear dirtieness and timeouts for all nodes and pins
    node_0.dirtyFlags = 0;
    node_1.dirtyFlags = 0;
    node_2.dirtyFlags = 0;
    node_3.dirtyFlags = 0;
    node_4.dirtyFlags = 0;
    node_5.dirtyFlags = 0;
    node_29.dirtyFlags = 0;
    node_30.dirtyFlags = 0;
    node_34.dirtyFlags = 0;
    node_38.dirtyFlags = 0;
    node_39.dirtyFlags = 0;
    node_40.dirtyFlags = 0;
    node_41.dirtyFlags = 0;
    node_42.dirtyFlags = 0;
    node_43.dirtyFlags = 0;
    node_44.dirtyFlags = 0;
    node_45.dirtyFlags = 0;
    node_46.dirtyFlags = 0;
    node_47.dirtyFlags = 0;
    node_48.dirtyFlags = 0;
    node_49.dirtyFlags = 0;
    node_50.dirtyFlags = 0;
    node_51.dirtyFlags = 0;
    node_52.dirtyFlags = 0;
    node_53.dirtyFlags = 0;
    node_54.dirtyFlags = 0;
    node_55.dirtyFlags = 0;
    node_56.dirtyFlags = 0;
    node_57.dirtyFlags = 0;
    node_58.dirtyFlags = 0;
    node_59.dirtyFlags = 0;
    node_60.dirtyFlags = 0;
    detail::clearStaleTimeout(&node_29);
    detail::clearStaleTimeout(&node_38);
    detail::clearStaleTimeout(&node_39);
    detail::clearStaleTimeout(&node_41);
    detail::clearStaleTimeout(&node_42);
    detail::clearStaleTimeout(&node_46);
    detail::clearStaleTimeout(&node_47);
    detail::clearStaleTimeout(&node_48);
    detail::clearStaleTimeout(&node_49);
    detail::clearStaleTimeout(&node_50);

    XOD_TRACE_F("Transaction completed, t=");
    XOD_TRACE_LN(millis());
}

} // namespace xod


errors:
Arduino: 1.8.8 (Windows 10), TD: 1.45, Board: "Arduino Nano, ATmega328P"

sketch_mar07a:1336:23: error: '____menu_base' is not a namespace-name

 namespace menu_base = ____menu_base;

                       ^

sketch_mar07a:1336:36: error: expected namespace-name before ';' token

 namespace menu_base = ____menu_base;

                                    ^

sketch_mar07a:1337:21: error: 'menu_base' does not name a type

 using menu_base_t = menu_base::MenuBase;

                     ^

sketch_mar07a:1339:14: error: 'menu_base' does not name a type

 using Type = menu_base::BiDirectionalList<menu_base_t*>;

              ^

sketch_mar07a:1342:5: error: 'menu_base' does not name a type

     menu_base::LeafMenuImpl<menu_base_t> leaf_menu;

     ^

sketch_mar07a:1343:5: error: 'menu_base' does not name a type

     menu_base::BiDirectionalPlainListView<menu_base_t*> leaf_menu_view =

     ^

sketch_mar07a:1350:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;

                                                   ^

sketch_mar07a:1379:99: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                   ^

sketch_mar07a:1414:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {

                                                          ^

sketch_mar07a:1437:98: error: 'xod::bitrex__xod_menu_system__leaf_menu_item_impl::Type' has not been declared

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                                                                                                  ^

sketch_mar07a:1437:17: error: template-id 'emitValue<xod::bitrex__xod_menu_system__leaf_menu_item_impl::output_OUT>' for 'void xod::bitrex__xod_menu_system__leaf_menu_item_impl::emitValue(xod::bitrex__xod_menu_system__leaf_menu_item_impl::Context, int)' does not match any template declaration

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                 ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In function 'void xod::bitrex__xod_menu_system__leaf_menu_item_impl::evaluate(xod::bitrex__xod_menu_system__leaf_menu_item_impl::Context)':

sketch_mar07a:1461:15: error: 'menu_base' has not been declared

         using menu_base::BiDirectionalPlainListView;

               ^

sketch_mar07a:1462:15: error: 'menu_base' has not been declared

         using menu_base::BiDirectionalList;

               ^

sketch_mar07a:1463:15: error: 'menu_base' has not been declared

         using menu_base::LeafMenuImpl;

               ^

sketch_mar07a:1467:16: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu_view'

         state->leaf_menu_view = menu_base::BiDirectionalPlainListView<menu_base_t*>(menu_base_p2p, 1);

                ^

sketch_mar07a:1467:33: error: 'menu_base' has not been declared

         state->leaf_menu_view = menu_base::BiDirectionalPlainListView<menu_base_t*>(menu_base_p2p, 1);

                                 ^

sketch_mar07a:1467:71: error: 'menu_base_t' was not declared in this scope

         state->leaf_menu_view = menu_base::BiDirectionalPlainListView<menu_base_t*>(menu_base_p2p, 1);

                                                                       ^

sketch_mar07a:1467:83: error: expected primary-expression before '>' token

         state->leaf_menu_view = menu_base::BiDirectionalPlainListView<menu_base_t*>(menu_base_p2p, 1);

                                                                                   ^

sketch_mar07a:1468:16: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu'

         state->leaf_menu = LeafMenuImpl<menu_base_t>(line1, line2, user_id);

                ^

sketch_mar07a:1468:28: error: 'LeafMenuImpl' was not declared in this scope

         state->leaf_menu = LeafMenuImpl<menu_base_t>(line1, line2, user_id);

                            ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:1468:28: note: suggested alternative:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:1274:20: note:   'xod::bitrex__xod_menu_system__menu_base::LeafMenuImpl'

 class LeafMenuImpl final : public LeafMenuInterface<MenuBase, LeafMenuImpl>,

                    ^

sketch_mar07a:1469:34: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu'

         *menu_base_p2p = &state->leaf_menu;

                                  ^

sketch_mar07a:1470:37: error: 'menu_base' has not been declared

         emitValue<output_OUT>(ctx,  menu_base::BiDirectionalList<menu_base_t*>(&state->leaf_menu_view));

                                     ^

sketch_mar07a:1470:78: error: expected primary-expression before '>' token

         emitValue<output_OUT>(ctx,  menu_base::BiDirectionalList<menu_base_t*>(&state->leaf_menu_view));

                                                                              ^

sketch_mar07a:1470:88: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu_view'

         emitValue<output_OUT>(ctx,  menu_base::BiDirectionalList<menu_base_t*>(&state->leaf_menu_view));

                                                                                        ^

sketch_mar07a:1475:38: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu_view'

         auto menu_base_ptr = *state->leaf_menu_view.iterate();

                                      ^

sketch_mar07a:1476:16: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu'

         state->leaf_menu.set_text(line1, line2);

                ^

sketch_mar07a:1478:31: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::State' has no member named 'leaf_menu'

         auto invoked = state->leaf_menu.update(&out);

                               ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:1993:23: error: '____menu_base' is not a namespace-name

 namespace menu_base = ____menu_base;

                       ^

sketch_mar07a:1993:36: error: expected namespace-name before ';' token

 namespace menu_base = ____menu_base;

                                    ^

sketch_mar07a:1994:21: error: 'menu_base' does not name a type

 using menu_base_t = menu_base::MenuBase;

                     ^

sketch_mar07a:2002:44: error: 'menu_base' has not been declared

 class BiDirectionalConcatListView : public menu_base::BiDirectionalListView<T> {

                                            ^

sketch_mar07a:2002:55: error: expected '{' before 'BiDirectionalListView'

 class BiDirectionalConcatListView : public menu_base::BiDirectionalListView<T> {

                                                       ^

sketch_mar07a:2002:76: error: expected initializer before '<' token

 class BiDirectionalConcatListView : public menu_base::BiDirectionalListView<T> {

                                                                            ^

sketch_mar07a:2087:33: error: 'menu_base_t' was not declared in this scope

     BiDirectionalConcatListView<menu_base_t*> menu_ptr_list_view;

                                 ^

sketch_mar07a:2087:45: error: template argument 1 is invalid

     BiDirectionalConcatListView<menu_base_t*> menu_ptr_list_view;

                                             ^

sketch_mar07a:2092:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;

                                                   ^

sketch_mar07a:2109:98: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<input_IN1> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                  ^

sketch_mar07a:2110:98: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<input_IN2> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                  ^

sketch_mar07a:2111:99: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                   ^

sketch_mar07a:2116:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN1;

                                                   ^

sketch_mar07a:2117:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN2;

                                                   ^

sketch_mar07a:2130:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN1>(Context ctx) {

                                                          ^

sketch_mar07a:2133:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN2>(Context ctx) {

                                                          ^

sketch_mar07a:2136:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {

                                                          ^

sketch_mar07a:2153:98: error: 'xod::bitrex__xod_menu_system__leaf_menu_item_impl::Type' has not been declared

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                                                                                                  ^

sketch_mar07a:2153:17: error: template-id 'emitValue<xod::bitrex__xod_menu_system__concat_menu::output_OUT>' for 'void xod::bitrex__xod_menu_system__concat_menu::emitValue(xod::bitrex__xod_menu_system__concat_menu::Context, int)' does not match any template declaration

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                 ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In function 'void xod::bitrex__xod_menu_system__concat_menu::evaluate(xod::bitrex__xod_menu_system__concat_menu::Context)':

sketch_mar07a:2164:15: error: 'menu_base' has not been declared

         using menu_base::BiDirectionalList;

               ^

sketch_mar07a:2166:49: error: no matching function for call to 'getValue(xod::bitrex__xod_menu_system__concat_menu::ContextObject*&)'

         const auto in1 = getValue<input_IN1>(ctx);

                                                 ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2123:53: note: candidate: template<class PinT> typename xod::bitrex__xod_menu_system__concat_menu::ValueType<PinT>::T xod::bitrex__xod_menu_system__concat_menu::getValue(xod::bitrex__xod_menu_system__concat_menu::Context)

 template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {

                                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2123:53: note:   template argument deduction/substitution failed:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In substitution of 'template<class PinT> typename xod::bitrex__xod_menu_system__concat_menu::ValueType<PinT>::T xod::bitrex__xod_menu_system__concat_menu::getValue(xod::bitrex__xod_menu_system__concat_menu::Context) [with PinT = xod::bitrex__xod_menu_system__concat_menu::input_IN1]':

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2166:49:   required from here

sketch_mar07a:2123:53: error: no type named 'T' in 'struct xod::bitrex__xod_menu_system__concat_menu::ValueType<xod::bitrex__xod_menu_system__concat_menu::input_IN1>'

sketch_mar07a:2167:49: error: no matching function for call to 'getValue(xod::bitrex__xod_menu_system__concat_menu::ContextObject*&)'

         const auto in2 = getValue<input_IN2>(ctx);

                                                 ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2123:53: note: candidate: template<class PinT> typename xod::bitrex__xod_menu_system__concat_menu::ValueType<PinT>::T xod::bitrex__xod_menu_system__concat_menu::getValue(xod::bitrex__xod_menu_system__concat_menu::Context)

 template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {

                                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2123:53: note:   template argument deduction/substitution failed:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In substitution of 'template<class PinT> typename xod::bitrex__xod_menu_system__concat_menu::ValueType<PinT>::T xod::bitrex__xod_menu_system__concat_menu::getValue(xod::bitrex__xod_menu_system__concat_menu::Context) [with PinT = xod::bitrex__xod_menu_system__concat_menu::input_IN2]':

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2167:49:   required from here

sketch_mar07a:2123:53: error: no type named 'T' in 'struct xod::bitrex__xod_menu_system__concat_menu::ValueType<xod::bitrex__xod_menu_system__concat_menu::input_IN2>'

sketch_mar07a:2170:65: error: 'menu_base_t' was not declared in this scope

         state->menu_ptr_list_view = BiDirectionalConcatListView<menu_base_t*>(in1, in2);

                                                                 ^

sketch_mar07a:2170:77: error: template argument 1 is invalid

         state->menu_ptr_list_view = BiDirectionalConcatListView<menu_base_t*>(in1, in2);

                                                                             ^

sketch_mar07a:2172:36: error: 'BiDirectionalList' was not declared in this scope

         emitValue<output_OUT>(ctx, BiDirectionalList<menu_base_t*>(&state->menu_ptr_list_view));

                                    ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2172:36: note: suggested alternative:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:1028:7: note:   'xod::bitrex__xod_menu_system__menu_base::BiDirectionalList'

 class BiDirectionalList : public List<T> {

       ^

sketch_mar07a:2172:66: error: expected primary-expression before '>' token

         emitValue<output_OUT>(ctx, BiDirectionalList<menu_base_t*>(&state->menu_ptr_list_view));

                                                                  ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:2286:23: error: '____menu_base' is not a namespace-name

 namespace menu_base = ____menu_base;

                       ^

sketch_mar07a:2286:36: error: expected namespace-name before ';' token

 namespace menu_base = ____menu_base;

                                    ^

sketch_mar07a:2287:21: error: 'menu_base' does not name a type

 using menu_base_t = menu_base::MenuBase;

                     ^

sketch_mar07a:2298:28: error: 'menu_base' has not been declared

   explicit SubMenuIterator(menu_base::BiDirectionalList<MenuBase*> sub_menus) :

                            ^

sketch_mar07a:2298:56: error: expected ')' before '<' token

   explicit SubMenuIterator(menu_base::BiDirectionalList<MenuBase*> sub_menus) :

                                                        ^

sketch_mar07a:2301:3: error: 'menu_base' does not name a type

   menu_base::BiDirectionalList<MenuBase*> menu_ptr_list() const {

   ^

sketch_mar07a:2326:5: error: 'menu_base' does not name a type

     menu_base::BiDirectionalList<MenuBase*> sub_menu_ptr_list_;

     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In member function 'MenuBase* xod::bitrex__xod_menu_system__branch_menu_item::SubMenuIterator<MenuBase>::current_menu_ptr()':

sketch_mar07a:2316:15: error: 'sub_menu_ptr_list_' was not declared in this scope

     auto it = sub_menu_ptr_list_.iterate();

               ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:2337:36: error: 'menu_base' has not been declared

 class BranchMenuInterface : public menu_base::MenuInterface<MenuBase, BranchMenuImpl> {

                                    ^

sketch_mar07a:2337:47: error: expected '{' before 'MenuInterface'

 class BranchMenuInterface : public menu_base::MenuInterface<MenuBase, BranchMenuImpl> {

                                               ^

sketch_mar07a:2337:60: error: expected initializer before '<' token

 class BranchMenuInterface : public menu_base::MenuInterface<MenuBase, BranchMenuImpl> {

                                                            ^

sketch_mar07a:2367:16: error: 'menu_base' has not been declared

   friend class menu_base::MenuInterface<MenuBase, BranchMenuImpl>;

                ^

sketch_mar07a:2367:40: error: expected unqualified-id before '<' token

   friend class menu_base::MenuInterface<MenuBase, BranchMenuImpl>;

                                        ^

sketch_mar07a:2375:18: error: 'menu_base' has not been declared

   BranchMenuImpl(menu_base::BiDirectionalList<MenuBase*> sub_menu_ptr_list,

                  ^

sketch_mar07a:2375:46: error: expected ')' before '<' token

   BranchMenuImpl(menu_base::BiDirectionalList<MenuBase*> sub_menu_ptr_list,

                                              ^

sketch_mar07a:2378:46: error: expected unqualified-id before ')' token

         menu_text_({menu_text_1, menu_text_2}),

                                              ^

sketch_mar07a:2429:18: error: 'menu_base_t' was not declared in this scope

   BranchMenuImpl<menu_base_t> branch_menu;

                  ^

sketch_mar07a:2429:29: error: template argument 1 is invalid

   BranchMenuImpl<menu_base_t> branch_menu;

                             ^

sketch_mar07a:2430:3: error: 'menu_base_t' does not name a type

   menu_base_t* branch_menu_ptr;

   ^

sketch_mar07a:2431:3: error: 'menu_base' does not name a type

   menu_base::BiDirectionalPlainListView<menu_base_t*> branch_menu_ptr_view =

   ^

sketch_mar07a:2437:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type output_OUT;

                                                   ^

sketch_mar07a:2456:97: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<input_IN> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                 ^

sketch_mar07a:2460:99: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<output_OUT> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                   ^

sketch_mar07a:2465:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_IN;

                                                   ^

sketch_mar07a:2481:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_IN>(Context ctx) {

                                                          ^

sketch_mar07a:2493:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<output_OUT>(Context ctx) {

                                                          ^

sketch_mar07a:2510:98: error: 'xod::bitrex__xod_menu_system__leaf_menu_item_impl::Type' has not been declared

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                                                                                                  ^

sketch_mar07a:2510:17: error: template-id 'emitValue<xod::bitrex__xod_menu_system__branch_menu_item::output_OUT>' for 'void xod::bitrex__xod_menu_system__branch_menu_item::emitValue(xod::bitrex__xod_menu_system__branch_menu_item::Context, int)' does not match any template declaration

 template<> void emitValue<output_OUT>(Context ctx, bitrex__xod_menu_system__leaf_menu_item_impl::Type val) {

                 ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In function 'void xod::bitrex__xod_menu_system__branch_menu_item::evaluate(xod::bitrex__xod_menu_system__branch_menu_item::Context)':

sketch_mar07a:2521:11: error: 'menu_base' has not been declared

     using menu_base::BiDirectionalList;

           ^

sketch_mar07a:2523:37: error: no matching function for call to 'getValue(xod::bitrex__xod_menu_system__branch_menu_item::ContextObject*&)'

     auto in = getValue<input_IN>(ctx);

                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2474:53: note: candidate: template<class PinT> typename xod::bitrex__xod_menu_system__branch_menu_item::ValueType<PinT>::T xod::bitrex__xod_menu_system__branch_menu_item::getValue(xod::bitrex__xod_menu_system__branch_menu_item::Context)

 template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {

                                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2474:53: note:   template argument deduction/substitution failed:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In substitution of 'template<class PinT> typename xod::bitrex__xod_menu_system__branch_menu_item::ValueType<PinT>::T xod::bitrex__xod_menu_system__branch_menu_item::getValue(xod::bitrex__xod_menu_system__branch_menu_item::Context) [with PinT = xod::bitrex__xod_menu_system__branch_menu_item::input_IN]':

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2523:37:   required from here

sketch_mar07a:2474:53: error: no type named 'T' in 'struct xod::bitrex__xod_menu_system__branch_menu_item::ValueType<xod::bitrex__xod_menu_system__branch_menu_item::input_IN>'

sketch_mar07a:2527:41: error: 'menu_base_t' was not declared in this scope

     state->branch_menu = BranchMenuImpl<menu_base_t>(in, text1, text2, id);

                                         ^

sketch_mar07a:2527:52: error: template argument 1 is invalid

     state->branch_menu = BranchMenuImpl<menu_base_t>(in, text1, text2, id);

                                                    ^

sketch_mar07a:2528:12: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::State' has no member named 'branch_menu_ptr'

     state->branch_menu_ptr = &state->branch_menu;

            ^

sketch_mar07a:2529:32: error: 'menu_base' has not been declared

     emitValue<output_OUT>(ctx, menu_base::BiDirectionalList<menu_base_t*>(&state->branch_menu_ptr_view));

                                ^

sketch_mar07a:2529:73: error: expected primary-expression before '>' token

     emitValue<output_OUT>(ctx, menu_base::BiDirectionalList<menu_base_t*>(&state->branch_menu_ptr_view));

                                                                         ^

sketch_mar07a:2529:83: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::State' has no member named 'branch_menu_ptr_view'

     emitValue<output_OUT>(ctx, menu_base::BiDirectionalList<menu_base_t*>(&state->branch_menu_ptr_view));

                                                                                   ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:2629:23: error: '____menu_base' is not a namespace-name

 namespace menu_base = ____menu_base;

                       ^

sketch_mar07a:2629:36: error: expected namespace-name before ';' token

 namespace menu_base = ____menu_base;

                                    ^

sketch_mar07a:2630:21: error: 'menu_base' does not name a type

 using menu_base_t = menu_base::MenuBase;

                     ^

sketch_mar07a:2631:30: error: '____branch_menu_item' is not a namespace-name

 namespace branch_menu_item = ____branch_menu_item;

                              ^

sketch_mar07a:2631:50: error: expected namespace-name before ';' token

 namespace branch_menu_item = ____branch_menu_item;

                                                  ^

sketch_mar07a:2644:23: error: 'branch_menu_item' has not been declared

   explicit MenuCursor(branch_menu_item::BranchMenuImpl<MenuBase>* top_menu)

                       ^

sketch_mar07a:2644:55: error: expected ')' before '<' token

   explicit MenuCursor(branch_menu_item::BranchMenuImpl<MenuBase>* top_menu)

                                                       ^

sketch_mar07a:2687:3: error: 'branch_menu_item' does not name a type

   branch_menu_item::BranchMenuImpl<MenuBase>* top_menu_ptr_ = nullptr;

   ^

sketch_mar07a:2688:3: error: 'branch_menu_item' does not name a type

   branch_menu_item::BranchMenuImpl<MenuBase>* current_root_menu_ptr_ = nullptr;

   ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In member function 'void xod::bitrex__xod_menu_system__menu_controller::MenuCursor<MenuBase>::back()':

sketch_mar07a:2650:23: error: 'current_root_menu_ptr_' was not declared in this scope

     auto parent_ptr = current_root_menu_ptr_->parent();

                       ^

sketch_mar07a:2651:47: error: 'top_menu_ptr_' was not declared in this scope

     if (parent_ptr && current_sub_menu_ptr_!= top_menu_ptr_) {

                                               ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In member function 'void xod::bitrex__xod_menu_system__menu_controller::MenuCursor<MenuBase>::left()':

sketch_mar07a:2661:9: error: 'current_root_menu_ptr_' was not declared in this scope

     if (current_root_menu_ptr_) {

         ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In member function 'void xod::bitrex__xod_menu_system__menu_controller::MenuCursor<MenuBase>::right()':

sketch_mar07a:2667:9: error: 'current_root_menu_ptr_' was not declared in this scope

     if (current_root_menu_ptr_) {

         ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In member function 'void xod::bitrex__xod_menu_system__menu_controller::MenuCursor<MenuBase>::invoke(xod::Number)':

sketch_mar07a:2675:30: error: 'current_root_menu_ptr_' was not declared in this scope

       auto prev_root_menu_ = current_root_menu_ptr_;

                              ^

sketch_mar07a:2677:23: error: 'branch_menu_item' does not name a type

           static_cast<branch_menu_item::BranchMenuImpl<MenuBase>*>(

                       ^

sketch_mar07a:2677:39: error: expected '>' before '::' token

           static_cast<branch_menu_item::BranchMenuImpl<MenuBase>*>(

                                       ^

sketch_mar07a:2677:39: error: expected '(' before '::' token

sketch_mar07a:2677:39: error: '::BranchMenuImpl' has not been declared

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2677:39: note: suggested alternative:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2364:22: note:   'xod::bitrex__xod_menu_system__branch_menu_item::BranchMenuImpl'

 class BranchMenuImpl final

                      ^

sketch_mar07a:2677:64: error: expected primary-expression before '>' token

           static_cast<branch_menu_item::BranchMenuImpl<MenuBase>*>(

                                                                ^

sketch_mar07a:2677:66: error: expected primary-expression before '>' token

           static_cast<branch_menu_item::BranchMenuImpl<MenuBase>*>(

                                                                  ^

sketch_mar07a:2678:24: error: expected ')' before ';' token

               menu_ptr);

                        ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:2696:14: error: 'menu_base_t' was not declared in this scope

   MenuCursor<menu_base_t> menu_cursor;

              ^

sketch_mar07a:2696:25: error: template argument 1 is invalid

   MenuCursor<menu_base_t> menu_cursor;

                         ^

sketch_mar07a:2697:3: error: 'branch_menu_item' does not name a type

   branch_menu_item::BranchMenuImpl<menu_base_t> root_menu;

   ^

sketch_mar07a:2735:104: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> struct ValueType<input_MENU_TREE> { using T = bitrex__xod_menu_system__leaf_menu_item_impl::Type; };

                                                                                                        ^

sketch_mar07a:2752:51: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

     bitrex__xod_menu_system__leaf_menu_item_impl::Type _input_MENU_TREE;

                                                   ^

sketch_mar07a:2778:58: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 template<> bitrex__xod_menu_system__leaf_menu_item_impl::Type getValue<input_MENU_TREE>(Context ctx) {

                                                          ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In function 'void xod::bitrex__xod_menu_system__menu_controller::evaluate(xod::bitrex__xod_menu_system__menu_controller::Context)':

sketch_mar07a:2876:12: error: 'struct xod::bitrex__xod_menu_system__menu_controller::State' has no member named 'root_menu'

     state->root_menu =

            ^

sketch_mar07a:2877:5: error: 'branch_menu_item' has not been declared

     branch_menu_item::BranchMenuImpl<menu_base_t>(getValue<input_MENU_TREE>(ctx), title_1,

     ^

sketch_mar07a:2877:38: error: 'menu_base_t' was not declared in this scope

     branch_menu_item::BranchMenuImpl<menu_base_t>(getValue<input_MENU_TREE>(ctx), title_1,

                                      ^

sketch_mar07a:2877:80: error: no matching function for call to 'getValue(xod::bitrex__xod_menu_system__menu_controller::ContextObject*&)'

     branch_menu_item::BranchMenuImpl<menu_base_t>(getValue<input_MENU_TREE>(ctx), title_1,

                                                                                ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2771:53: note: candidate: template<class PinT> typename xod::bitrex__xod_menu_system__menu_controller::ValueType<PinT>::T xod::bitrex__xod_menu_system__menu_controller::getValue(xod::bitrex__xod_menu_system__menu_controller::Context)

 template<typename PinT> typename ValueType<PinT>::T getValue(Context ctx) {

                                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2771:53: note:   template argument deduction/substitution failed:

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In substitution of 'template<class PinT> typename xod::bitrex__xod_menu_system__menu_controller::ValueType<PinT>::T xod::bitrex__xod_menu_system__menu_controller::getValue(xod::bitrex__xod_menu_system__menu_controller::Context) [with PinT = xod::bitrex__xod_menu_system__menu_controller::input_MENU_TREE]':

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2877:80:   required from here

sketch_mar07a:2771:53: error: no type named 'T' in 'struct xod::bitrex__xod_menu_system__menu_controller::ValueType<xod::bitrex__xod_menu_system__menu_controller::input_MENU_TREE>'

sketch_mar07a:2879:12: error: 'struct xod::bitrex__xod_menu_system__menu_controller::State' has no member named 'root_menu'

     state->root_menu.set_parent(&state->root_menu);

            ^

sketch_mar07a:2879:41: error: 'struct xod::bitrex__xod_menu_system__menu_controller::State' has no member named 'root_menu'

     state->root_menu.set_parent(&state->root_menu);

                                         ^

sketch_mar07a:2880:37: error: the value of 'menu_base_t' is not usable in a constant expression

     state->menu_cursor = MenuCursor<menu_base_t>(&state->root_menu);

                                     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2877:38: note: 'menu_base_t' was not declared 'constexpr'

     branch_menu_item::BranchMenuImpl<menu_base_t>(getValue<input_MENU_TREE>(ctx), title_1,

                                      ^

sketch_mar07a:2880:48: error: type/value mismatch at argument 1 in template parameter list for 'template<class MenuBase> class xod::bitrex__xod_menu_system__menu_controller::MenuCursor'

     state->menu_cursor = MenuCursor<menu_base_t>(&state->root_menu);

                                                ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino:2880:48: note:   expected a type, got 'menu_base_t'

sketch_mar07a:2880:58: error: 'struct xod::bitrex__xod_menu_system__menu_controller::State' has no member named 'root_menu'

     state->menu_cursor = MenuCursor<menu_base_t>(&state->root_menu);

                                                          ^

sketch_mar07a:2891:24: error: request for member 'back' in 'state->xod::bitrex__xod_menu_system__menu_controller::State::menu_cursor', which is of non-class type 'int'

     state->menu_cursor.back();

                        ^

sketch_mar07a:2894:24: error: request for member 'left' in 'state->xod::bitrex__xod_menu_system__menu_controller::State::menu_cursor', which is of non-class type 'int'

     state->menu_cursor.left();

                        ^

sketch_mar07a:2897:24: error: request for member 'right' in 'state->xod::bitrex__xod_menu_system__menu_controller::State::menu_cursor', which is of non-class type 'int'

     state->menu_cursor.right();

                        ^

sketch_mar07a:2903:24: error: request for member 'invoke' in 'state->xod::bitrex__xod_menu_system__menu_controller::State::menu_cursor', which is of non-class type 'int'

     state->menu_cursor.invoke(param);

                        ^

sketch_mar07a:2908:39: error: request for member 'text' in 'state->xod::bitrex__xod_menu_system__menu_controller::State::menu_cursor', which is of non-class type 'int'

   auto text_list = state->menu_cursor.text();

                                       ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: At global scope:

sketch_mar07a:3199:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_38_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3203:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_39_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3211:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_41_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3215:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_42_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3225:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_44_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3227:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_45_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3239:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_51_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3241:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_52_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3253:57: error: 'Type' in namespace 'xod::bitrex__xod_menu_system__leaf_menu_item_impl' does not name a type

 constexpr bitrex__xod_menu_system__leaf_menu_item_impl::Type node_58_output_OUT = { /* bitrex/xod-menu-system/leaf-menu-item-impl */ };

                                                         ^

sketch_mar07a:3322:5: error: 'node_38_output_OUT' was not declared in this scope

     node_38_output_OUT, // output OUT default

     ^

sketch_mar07a:3333:5: error: 'node_39_output_OUT' was not declared in this scope

     node_39_output_OUT, // output OUT default

     ^

sketch_mar07a:3354:5: error: 'node_41_output_OUT' was not declared in this scope

     node_41_output_OUT, // output OUT default

     ^

sketch_mar07a:3365:5: error: 'node_42_output_OUT' was not declared in this scope

     node_42_output_OUT, // output OUT default

     ^

sketch_mar07a:3389:5: error: 'node_44_output_OUT' was not declared in this scope

     node_44_output_OUT, // output OUT default

     ^

sketch_mar07a:3395:5: error: 'node_45_output_OUT' was not declared in this scope

     node_45_output_OUT, // output OUT default

     ^

sketch_mar07a:3436:5: error: 'node_51_output_OUT' was not declared in this scope

     node_51_output_OUT, // output OUT default

     ^

sketch_mar07a:3442:5: error: 'node_52_output_OUT' was not declared in this scope

     node_52_output_OUT, // output OUT default

     ^

sketch_mar07a:3478:5: error: 'node_58_output_OUT' was not declared in this scope

     node_58_output_OUT, // output OUT default

     ^

C:\Users\taran\Documents\Arduino\sketch_mar07a\sketch_mar07a.ino: In function 'void xod::runTransaction()':

sketch_mar07a:3821:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN1'

             ctxObj._input_IN1 = node_39.output_OUT;

                    ^

sketch_mar07a:3821:41: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::Node' has no member named 'output_OUT'

             ctxObj._input_IN1 = node_39.output_OUT;

                                         ^

sketch_mar07a:3822:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN2'

             ctxObj._input_IN2 = node_41.output_OUT;

                    ^

sketch_mar07a:3822:41: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::Node' has no member named 'output_OUT'

             ctxObj._input_IN2 = node_41.output_OUT;

                                         ^

sketch_mar07a:3839:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN1'

             ctxObj._input_IN1 = node_38.output_OUT;

                    ^

sketch_mar07a:3839:41: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::Node' has no member named 'output_OUT'

             ctxObj._input_IN1 = node_38.output_OUT;

                                         ^

sketch_mar07a:3840:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN2'

             ctxObj._input_IN2 = node_42.output_OUT;

                    ^

sketch_mar07a:3840:41: error: 'struct xod::bitrex__xod_menu_system__leaf_menu_item_impl::Node' has no member named 'output_OUT'

             ctxObj._input_IN2 = node_42.output_OUT;

                                         ^

sketch_mar07a:3947:20: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::ContextObject' has no member named '_input_IN'

             ctxObj._input_IN = node_44.output_OUT;

                    ^

sketch_mar07a:3947:40: error: 'struct xod::bitrex__xod_menu_system__concat_menu::Node' has no member named 'output_OUT'

             ctxObj._input_IN = node_44.output_OUT;

                                        ^

sketch_mar07a:3967:20: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::ContextObject' has no member named '_input_IN'

             ctxObj._input_IN = node_45.output_OUT;

                    ^

sketch_mar07a:3967:40: error: 'struct xod::bitrex__xod_menu_system__concat_menu::Node' has no member named 'output_OUT'

             ctxObj._input_IN = node_45.output_OUT;

                                        ^

sketch_mar07a:4069:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN1'

             ctxObj._input_IN1 = node_51.output_OUT;

                    ^

sketch_mar07a:4069:41: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::Node' has no member named 'output_OUT'

             ctxObj._input_IN1 = node_51.output_OUT;

                                         ^

sketch_mar07a:4070:20: error: 'struct xod::bitrex__xod_menu_system__concat_menu::ContextObject' has no member named '_input_IN2'

             ctxObj._input_IN2 = node_52.output_OUT;

                    ^

sketch_mar07a:4070:41: error: 'struct xod::bitrex__xod_menu_system__branch_menu_item::Node' has no member named 'output_OUT'

             ctxObj._input_IN2 = node_52.output_OUT;

                                         ^

sketch_mar07a:4087:20: error: 'struct xod::bitrex__xod_menu_system__menu_controller::ContextObject' has no member named '_input_MENU_TREE'

             ctxObj._input_MENU_TREE = node_58.output_OUT;

                    ^

sketch_mar07a:4087:47: error: 'struct xod::bitrex__xod_menu_system__concat_menu::Node' has no member named 'output_OUT'

             ctxObj._input_MENU_TREE = node_58.output_OUT;

                                               ^

exit status 1
'____menu_base' is not a namespace-name

Invalid library found in C:\Users\taran\Documents\Arduino\libraries\20180202_vu_meter_update: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\20180202_vu_meter_update
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\Adafruit: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\Adafruit
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\BlinkyBall-master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\BlinkyBall-master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\CH341SER: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\CH341SER
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\keypad_values: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\keypad_values
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\micropython-ws2812-master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\micropython-ws2812-master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\multiplesketches_master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\multiplesketches_master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\simple_lcd_menu: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\simple_lcd_menu
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\SmartMatrix3-3.0.1: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\SmartMatrix3-3.0.1
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\Yahzee: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\Yahzee
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\20180202_vu_meter_update: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\20180202_vu_meter_update
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\Adafruit: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\Adafruit
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\BlinkyBall-master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\BlinkyBall-master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\CH341SER: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\CH341SER
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\keypad_values: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\keypad_values
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\micropython-ws2812-master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\micropython-ws2812-master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\multiplesketches_master: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\multiplesketches_master
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\simple_lcd_menu: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\simple_lcd_menu
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\SmartMatrix3-3.0.1: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\SmartMatrix3-3.0.1
Invalid library found in C:\Users\taran\Documents\Arduino\libraries\Yahzee: no headers files (.h) found in C:\Users\taran\Documents\Arduino\libraries\Yahzee