/*
* Copyright © 2020 Jørgen Lind

* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission.  The copyright holders make no representations
* about the suitability of this software for any purpose.  It is provided "as
* is" without express or implied warranty.

* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/

/*! \file */

/*! \mainpage json_struct
 *
 * json_struct is a set of classes meant for simple and efficient parse,
 * tokenize and validate json.
 *
 * json_struct support parsing json into a stream of tokens using the \ref
 * tokenizer "JS::Tokenizer" api, or parsing json into c++ structures using the
 * \ref js_struct "JS_OBJECT" api.
 */

/*! \page tokenizer Parsing json using JS::Tokenizer
 *
 * Tokenizing json JS::Tokenizer can be used to extract tokens
 * from a json stream.  Tokens does not describe a full object, but only
 * key-value pairs. So a object would be: "some key" and object start. Then the
 * next token would be the first key value pair of that object. Then at some
 * point the object is finished, and an object end value with no key would be
 * the token.
 *
 * Arrays would be expressed in a similar fashion, but the tokens would have no
 * key, and each element in the array would be tokens with only a value
 * specified.
 *
 * The root object would be a token with no key data, but only object or array
 * start
 *
 * A crude example of this is viewed in \ref simple_tokenize.cpp here:
 * \include simple_tokenize.cpp
 *
 * Tokenizing json in this way allows you parse arbitrary large json data.
 * Also the tokenizer has mechanisms for asking for more data, making it easy
 * to stream json data. Using this interface to parse json is a bit verbose and
 * requires the application code to keep some extra state. json_struct also has
 * functionality for parsing json data directly into c++ structures. This is
 * done by adding some metadata to the structure, or by adding a template
 * specialisation of a class.  \ref js_struct "describes this" in more detail.
 */

/*! \example simple_tokenize.cpp
 *
 * This example show very basic usage of how JS::Tokenizer can be used
 */

/*! \example simple_struct.cpp
 *
 * This example shows basic usage of parsing Json directly into structs
 */

/*! \page js_struct Parsing json into C++ structs
 *
 * json_struct makes it very easy to put your json data into c++ structures or
 * take data from c++ structures and generate json.
 *
 * This is best shown with an example: \include simple_struct.cpp
 *
 * The two interesting sections here are the lines are the:
 * \code{.cpp}
 *    JS_OBJECT(JS_MEMBER(key),
 *              JS_MEMBER(number),
 *              JS_MEMBER(boolean));
 * \endcode
 *
 * and
 *
 * \code{.cpp}
 *    JS::ParseContext parseContext(json);
 *    JsonData dataStruct;
 *    parseContext.parseTo(dataStruct);
 * \endcode
 *
 * The JS_OBJECT call inside the JsonData struct will create a nested struct
 * declaration inside the JsonData struct. This nested struct will expose some
 * meta data about the struct, exposing the names of the members at runtime.
 * json_struct can then use this runtime information to populate the struct.
 *
 * Populating the struct is done by first creating a JS::ParseContext. The
 * JS::ParseContext contains a JS::Tokenizer. This tokenizer is what the actual
 * state holder for the parsing. If allowing using '\n' instead of ',' to
 * seperate object and array elements, then this should be set on the
 * JS::Tokenizer.
 *
 * Since types will dictate the schema of the input json, the JS::ParseContext
 * will expose a list containing what members where not populated by the input
 * json, and what member in the input json that did not have any member to
 * populate.
 */

#ifndef JSON_STRUCT_H
#define JSON_STRUCT_H

#include <algorithm>
#include <assert.h>
#include <atomic>
#include <cmath>
#include <cstring>
#include <functional>
#include <limits>
#include <memory>
#include <stddef.h>
#include <stdlib.h>
#include <string>
#include <vector>

#ifdef _MSC_VER
#include <intrin.h>
#endif

#if __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER > 1800)
#define JS_STD_UNORDERED_MAP 1
#endif
#ifdef JS_STD_UNORDERED_MAP
#include <unordered_map>
#endif

#ifndef JS_STD_OPTIONAL
#if defined(__APPLE__)
#if __clang_major__ > 9 && __cplusplus >= 201703L
#define JS_STD_OPTIONAL 1
#endif
#elif defined(_MSC_VER) && _MSC_VER >= 1910 && _HAS_CXX17
#define JS_STD_OPTIONAL 1
#elif __cplusplus >= 201703L
#define JS_STD_OPTIONAL 1
#endif
#endif

#ifdef JS_STD_OPTIONAL
#include <optional>
#endif

#ifdef JS_STD_TIMEPOINT
#include <chrono>
#include <type_traits>
#endif

#ifndef JS_IF_CONSTEXPR
#if __cpp_if_constexpr
#define JS_IF_CONSTEXPR(exp) if constexpr (exp)
#elif defined(_MSC_VER)
#define JS_IF_CONSTEXPR(exp) __pragma(warning(push)) __pragma(warning(disable : 4127)) if (exp) __pragma(warning(pop))
#else
#define JS_IF_CONSTEXPR(exp) if (exp)
#endif
#endif

#if JS_NO_NODISCARD
#define JS_NODISCARD
#else
#if __cplusplus >= 201703L
#define JS_NODISCARD [[nodiscard]]
#else
#define JS_NODISCARD
#endif
#endif

#if defined(min) || defined(max)
#error min or max macro is defined. Make sure these are not defined before including json_struct.h.\
 Use "#define NOMINMAX 1" before including Windows.h
#endif

#define JS_UNUSED(x) (void)(x)

#ifndef JS
#define JS JS
#endif

namespace
JS {
  /*!
   *  \brief Pointer to data
   *
   *  DataRef is used to refere to some data inside a json string. It holds the
   *  start posisition of the data, and its size.
   */
  struct DataRef {
    /*!
     * Constructs a null Dataref pointing to "" with size 0.
     */
    constexpr explicit DataRef()
      : data("")
        , size(0) {
    }

    /*!
     * Constructs a DataRef pointing to data and size.
     * \param data points to start of data.
     * \param size size of data.
     */
    constexpr explicit DataRef(const char *data, size_t size)
      : data(data)
        , size(size) {
    }

    /*!  Cobstructs a DataRef pointing to an array. This will \b NOT look for
     * the null terminator, but just initialize the DataRef to the size of the
     * array - 1. This function is intended to be used with string literals.
     * \param data  start of the data.
     */
    template<size_t N>
    constexpr explicit DataRef(const char (&data)[N])
      : data(data)
        , size(N - 1) {
    }

    explicit DataRef(const std::string &str)
      : data(&str[0])
        , size(str.size()) {
    }

    explicit DataRef(const char *data)
      : data(data)
        , size(strlen(data)) {
    }

    const char *data;
    size_t size;
  };

  enum class Type : unsigned char {
    Error,
    String,
    Ascii,
    Number,
    ObjectStart,
    ObjectEnd,
    ArrayStart,
    ArrayEnd,
    Bool,
    Null,
    Verbatim
  };

  struct Token {
    Token();

    DataRef name;
    DataRef value;
    Type name_type;
    Type value_type;
  };

  namespace Internal {
    struct IntermediateToken {
      IntermediateToken()
        : active(false)
          , name_type_set(false)
          , data_type_set(false) {
      }

      void clear() {
        if (!active)
          return;
        active = false;
        name_type_set = false;
        data_type_set = false;
        name_type = Type::Error;
        data_type = Type::Error;
        name.clear();
        data.clear();
      }

      bool active: 1;
      bool name_type_set: 1;
      bool data_type_set: 1;
      Type name_type = Type::Error;
      Type data_type = Type::Error;
      std::string name;
      std::string data;
    };

    enum Lookup {
      StrEndOrBackSlash = 1,
      AsciiLetters = 2,
      WhiteSpaceOrNull = 4,
      PlusOrMinus = 8,
      Digits = 16,
      HatUnderscoreAprostoph = 32,
      NumberEnd = 64
    };

    static inline const unsigned char *lookup() {
      static const unsigned char tmp[] = {
        /*0*/ 4, 0, 0, 0, 0, 0, 0, 0,
        /*8*/ 0, 4, 4, 0, 0, 4, 0, 0,
        /*16*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*24*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*32*/ 4, 0, 1, 0, 0, 0, 0, 0,
        /*40*/ 0, 0, 0, 8 | 64, 0, 8 | 64, 64, 0,
        /*48*/ 16 | 64, 16 | 64, 16 | 64, 16 | 64, 16 | 64, 16 | 64, 16 | 64, 16 | 64,
        /*56*/ 16 | 64, 16 | 64, 0, 0, 0, 0, 0, 0,
        /*64*/ 0, 2, 2, 2, 2, 2 | 64, 2, 2,
        /*72*/ 2, 2, 2, 2, 2, 2, 2, 2,
        /*80*/ 2, 2, 2, 2, 2, 2, 2, 2,
        /*88*/ 2, 2, 2, 0, 1, 0, 32, 32,
        /*96*/ 32, 2, 2, 2, 2, 2 | 64, 2, 2,
        /*104*/ 2, 2, 2, 2, 2, 2, 2, 2,
        /*112*/ 2, 2, 2, 2, 2, 2, 2, 2,
        /*120*/ 2, 2, 2, 0, 0, 0, 0, 0,
        /*128*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*136*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*144*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*152*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*160*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*168*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*176*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*184*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*192*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*200*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*208*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*216*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*224*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*232*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*240*/ 0, 0, 0, 0, 0, 0, 0, 0,
        /*248*/ 0, 0, 0, 0, 0, 0, 0, 0
      };
      return tmp;
    }
  } // namespace Internal

  enum class Error : unsigned char {
    NoError,
    NeedMoreData,
    InvalidToken,
    ExpectedPropertyName,
    ExpectedDelimiter,
    ExpectedDataToken,
    ExpectedObjectStart,
    ExpectedObjectEnd,
    ExpectedArrayStart,
    ExpectedArrayEnd,
    UnexpectedArrayEnd,
    UnexpectedObjectEnd,
    IllegalPropertyName,
    IllegalPropertyType,
    IllegalDataValue,
    EncounteredIllegalChar,
    NodeNotFound,
    MissingPropertyMember,
    MissingFunction,
    FailedToParseBoolean,
    FailedToParseDouble,
    FailedToParseFloat,
    FailedToParseInt,
    UnassignedRequiredMember,
    NonContigiousMemory,
    ScopeHasEnded,
    KeyNotFound,
    DuplicateInSet,
    UnknownError,
    UserDefinedErrors
  };

  namespace Internal {
    class ErrorContext {
    public:
      size_t line = 0;
      size_t character = 0;
      Error error = Error::NoError;
      std::string custom_message;
      std::vector<std::string> lines;

      void clear() {
        line = 0;
        character = 0;
        error = Error::NoError;
        lines.clear();
      }
    };

    template<typename T>
    struct CallbackContainer;
  } // namespace Internal

  template<typename T>
  class RefCounter {
  public:
    RefCounter()
      : callbackContainer(nullptr)
        , index(0) {
    }

    RefCounter(size_t index, Internal::CallbackContainer<T> *callbackContainer)
      : callbackContainer(callbackContainer)
        , index(index) {
      inc();
    }

    RefCounter(const RefCounter<T> &other)
      : callbackContainer(other.callbackContainer) {
      inc();
    }

    RefCounter<T> &operator=(const RefCounter<T> &other) {
      dec();
      callbackContainer = other.callbackContainer;
      index = other.index;
      inc();
      return *this;
    }

    ~RefCounter() {
      dec();
    }

  private:
    void inc();

    void dec();

    Internal::CallbackContainer<T> *callbackContainer;
    size_t index;
  };

  template<typename T>
  class Callback {
  public:
    Callback()
      : ref(0) {
    }

    Callback(std::function<T> &callback)
      : ref(0)
        , callback(callback) {
    }

    Callback(const Callback<T> &other)
      : ref(other.ref.load())
        , callback(other.callback) {
    }

    Callback &operator=(const Callback<T> &other) {
      ref.store(other.ref.load());
      callback = other.callback;
      return *this;
    }

    void inc() {
      ++ref;
    }

    void dec() {
      --ref;
    }

    std::atomic<int> ref;
    std::function<T> callback;
  };

  namespace Internal {
    template<typename T>
    struct CallbackContainer {
    public:
      const RefCounter<T> addCallback(std::function<T> &callback) {
        for (size_t i = 0; i < vec.size(); i++) {
          if (vec[i].ref.load() == 0) {
            vec[i].callback = callback;
            return RefCounter<T>(i, this);
          }
        }
        vec.push_back(Callback<T>(callback));
        return RefCounter<T>(vec.size() - 1, this);
      }

      template<typename... Ts>
      void invokeCallbacks(Ts &... args) {
        for (auto &callbackHandler: vec) {
          if (callbackHandler.ref.load()) {
            callbackHandler.callback(args...);
          }
        }
      }

      void inc(size_t index) {
        assert(index < vec.size());
        ++vec[index].ref;
      }

      void dec(size_t index) {
        assert(index < vec.size());
        assert(vec[index].ref.load() != 0);
        --vec[index].ref;
      }

    private:
      std::vector<Callback<T> > vec;
    };

    struct ScopeCounter {
      JS::Type type;
      uint16_t depth;

      inline void handleType(JS::Type in_type) {
        if (type == JS::Type::ArrayStart || type == JS::Type::ObjectStart) {
          if (in_type == type)
            depth++;
          else if (in_type == JS::Type(static_cast<int>(type) + 1))
            depth--;
        } else {
          depth--;
        }
      }
    };
  } // namespace Internal

  template<typename T>
  inline void RefCounter<T>::inc() {
    if (callbackContainer)
      callbackContainer->inc(index);
  }

  template<typename T>
  inline void RefCounter<T>::dec() {
    if (callbackContainer)
      callbackContainer->dec(index);
  }

  class Tokenizer;
  typedef RefCounter<void(const char *)> ReleaseCBRef;
  typedef RefCounter<void(Tokenizer &)> NeedMoreDataCBRef;

  class Tokenizer {
  public:
    Tokenizer();

    void allowAsciiType(bool allow);

    void allowNewLineAsTokenDelimiter(bool allow);

    void allowSuperfluousComma(bool allow);

    void addData(const char *data, size_t size);

    template<size_t N>
    void addData(const char (&data)[N]);

    void addData(const std::vector<Token> *parsedData);

    void resetData(const char *data, size_t size, size_t index);

    void resetData(const std::vector<Token> *parsedData, size_t index);

    size_t registeredBuffers() const;

    NeedMoreDataCBRef registerNeedMoreDataCallback(std::function<void(Tokenizer &)> callback);

    ReleaseCBRef registerReleaseCallback(std::function<void(const char *)> &callback);

    Error nextToken(Token &next_token);

    const char *currentPosition() const;

    void copyFromValue(const Token &token, std::string &to_buffer);

    void copyIncludingValue(const Token &token, std::string &to_buffer);

    void pushScope(JS::Type type);

    void popScope();

    JS::Error goToEndOfScope(JS::Token &token);

    std::string makeErrorString() const;

    void setErrorContextConfig(size_t lineContext, size_t rangeContext);

    Error updateErrorContext(Error error, const std::string &custom_message = std::string());

    const Internal::ErrorContext &errorContext() const {
      return error_context;
    }

  private:
    enum class InTokenState : unsigned char {
      FindingName,
      FindingDelimiter,
      FindingData,
      FindingTokenEnd
    };

    enum class InPropertyState : unsigned char {
      NoStartFound,
      FindingEnd,
      FoundEnd
    };

    void resetForNewToken();

    void resetForNewValue();

    Error findStringEnd(const DataRef &json_data, size_t *chars_ahead);

    Error findAsciiEnd(const DataRef &json_data, size_t *chars_ahead);

    Error findNumberEnd(const DataRef &json_data, size_t *chars_ahead);

    Error findStartOfNextValue(Type *type, const DataRef &json_data, size_t *chars_ahead);

    Error findDelimiter(const DataRef &json_data, size_t *chars_ahead);

    Error findTokenEnd(const DataRef &json_data, size_t *chars_ahead);

    void requestMoreData();

    void releaseFirstDataRef();

    Error populateFromDataRef(DataRef &data, Type &type, const DataRef &json_data);

    static void populate_annonymous_token(const DataRef &data, Type type, Token &token);

    Error populateNextTokenFromDataRef(Token &next_token, const DataRef &json_data);

    InTokenState token_state = InTokenState::FindingName;
    InPropertyState property_state = InPropertyState::NoStartFound;
    Type property_type = Type::Error;
    bool is_escaped: 1;
    bool allow_ascii_properties: 1;
    bool allow_new_lines: 1;
    bool allow_superfluous_comma: 1;
    bool expecting_prop_or_annonymous_data: 1;
    bool continue_after_need_more_data: 1;
    size_t cursor_index;
    size_t current_data_start;
    size_t line_context;
    size_t line_range_context;
    size_t range_context;
    Internal::IntermediateToken intermediate_token;
    std::vector<DataRef> data_list;
    std::vector<Internal::ScopeCounter> scope_counter;
    std::vector<Type> container_stack;
    Internal::CallbackContainer<void(const char *)> release_callbacks;
    Internal::CallbackContainer<void(Tokenizer &)> need_more_data_callbacks;
    std::vector<std::pair<size_t, std::string *> > copy_buffers;
    const std::vector<Token> *parsed_data_vector;
    Internal::ErrorContext error_context;
  };

  namespace Internal {
    template<size_t SIZE>
    struct StringLiteral {
      const char *data;

      enum size_enum {
        size = SIZE
      };
    };

    template<size_t SIZE>
    constexpr StringLiteral<SIZE - 1> makeStringLiteral(const char (&literal)[SIZE]) {
      return {literal};
    }
  }

  class SerializerOptions {
  public:
    enum Style : unsigned char {
      Pretty,
      Compact
    };

    SerializerOptions(Style style = Style::Pretty);

    int shiftSize() const;

    void setShiftSize(unsigned char set);

    Style style() const;

    void setStyle(Style style);

    bool convertAsciiToString() const;

    void setConvertAsciiToString(bool set);

    unsigned char depth() const;

    void setDepth(int depth);

    void skipDelimiter(bool skip);

    const std::string &prefix() const;

    const std::string &tokenDelimiter() const;

    const std::string &valueDelimiter() const;

    const std::string &postfix() const;

  private:
    uint8_t m_shift_size;
    uint8_t m_depth;
    Style m_style;
    bool m_convert_ascii_to_string;

    std::string m_prefix;
    std::string m_token_delimiter;
    std::string m_value_delimiter;
    std::string m_postfix;
  };

#if __cplusplus >= 201403L
template <SerializerOptions::Style S = SerializerOptions::Style::Pretty>
const static SerializerOptions DEFAULT_OPS =
  []() { // NOLINT(cppcoreguidelines-avoid-non-const-global-variables,cert-err58-cpp)
    SerializerOptions ops(S);
    return ops;
  }();
#endif

  class SerializerBuffer {
  public:
    SerializerBuffer()
      : buffer(nullptr)
        , size(0)
        , used(0) {
    }

    SerializerBuffer(char *buffer, size_t size)
      : buffer(buffer)
        , size(size)
        , used(0) {
    }

    size_t free() const {
      return size - used;
    }

    void append(const char *data, size_t size);

    template<size_t SIZE>
    void append(const char *data);

    char *buffer;
    size_t size;
    size_t used;
  };

  class Serializer;
  typedef RefCounter<void(Serializer &)> BufferRequestCBRef;

  class Serializer {
  public:
    Serializer();

    Serializer(char *buffer, size_t size);

    void setBuffer(char *buffer, size_t size);

    void setOptions(const SerializerOptions &option);

    SerializerOptions options() const {
      return m_option;
    }

    bool write(const Token &token);

    bool write(const char *data, size_t size);

    bool write(const std::string &str) {
      return write(str.c_str(), str.size());
    }

    template<size_t SIZE>
    inline bool write(const Internal::StringLiteral<SIZE> &strLiteral);

    const BufferRequestCBRef addRequestBufferCallback(std::function<void(Serializer &)> callback);

    const SerializerBuffer &currentBuffer() const;

  private:
    void askForMoreBuffers();

    void markCurrentSerializerBufferFull();

    bool writeAsString(const DataRef &data);

    bool write(Type type, const DataRef &data);

    Internal::CallbackContainer<void(Serializer &)> m_request_buffer_callbacks;
    SerializerBuffer m_current_buffer;

    bool m_first;
    bool m_token_start;
    SerializerOptions m_option;
  };

  // IMPLEMENTATION

  inline Token::Token()
    : name()
      , value()
      , name_type(Type::String)
      , value_type(Type::String) {
  }

  inline Tokenizer::Tokenizer()
    : is_escaped(false)
      , allow_ascii_properties(false)
      , allow_new_lines(false)
      , allow_superfluous_comma(false)
      , expecting_prop_or_annonymous_data(false)
      , continue_after_need_more_data(false)
      , cursor_index(0)
      , current_data_start(0)
      , line_context(4)
      , line_range_context(256)
      , range_context(38)
      , parsed_data_vector(nullptr) {
    container_stack.reserve(16);
  }

  inline void Tokenizer::allowAsciiType(bool allow) {
    allow_ascii_properties = allow;
  }

  inline void Tokenizer::allowNewLineAsTokenDelimiter(bool allow) {
    allow_new_lines = allow;
  }

  inline void Tokenizer::allowSuperfluousComma(bool allow) {
    allow_superfluous_comma = allow;
  }

  inline void Tokenizer::addData(const char *data, size_t data_size) {
    data_list.push_back(DataRef(data, data_size));
  }

  template<size_t N>
  inline void Tokenizer::addData(const char (&data)[N]) {
    data_list.push_back(DataRef(data));
  }

  inline void Tokenizer::addData(const std::vector<Token> *parsedData) {
    assert(parsed_data_vector == 0);
    parsed_data_vector = parsedData;
    cursor_index = 0;
  }

  inline void Tokenizer::resetData(const char *data, size_t size, size_t index) {
    for (auto &data_buffer: data_list)
      release_callbacks.invokeCallbacks(data_buffer.data);
    data_list.clear();
    parsed_data_vector = nullptr;
    cursor_index = index;
    addData(data, size);
    resetForNewToken();
  }

  inline void Tokenizer::resetData(const std::vector<Token> *parsedData, size_t index) {
    for (auto &data_buffer: data_list)
      release_callbacks.invokeCallbacks(data_buffer.data);
    data_list.clear();
    parsed_data_vector = parsedData;
    cursor_index = index;
    resetForNewToken();
  }

  inline size_t Tokenizer::registeredBuffers() const {
    return data_list.size();
  }

  inline NeedMoreDataCBRef Tokenizer::registerNeedMoreDataCallback(std::function<void(Tokenizer &)> callback) {
    return need_more_data_callbacks.addCallback(callback);
  }

  inline ReleaseCBRef Tokenizer::registerReleaseCallback(std::function<void(const char *)> &callback) {
    return release_callbacks.addCallback(callback);
  }

  inline Error Tokenizer::nextToken(Token &next_token) {
    assert(!scope_counter.size() ||
      (scope_counter.back().type != JS::Type::ArrayEnd && scope_counter.back().type != JS::Type::ObjectEnd));
    if (scope_counter.size() && scope_counter.back().depth == 0) {
      return Error::ScopeHasEnded;
    }
    if (parsed_data_vector) {
      next_token = (*parsed_data_vector)[cursor_index];
      cursor_index++;
      if (cursor_index == parsed_data_vector->size()) {
        cursor_index = 0;
        parsed_data_vector = nullptr;
      }
      if (scope_counter.size())
        scope_counter.back().handleType(next_token.value_type);
      return Error::NoError;
    }
    if (data_list.empty()) {
      requestMoreData();
    }

    error_context.clear();

    if (data_list.empty()) {
      return Error::NeedMoreData;
    }

    if (!continue_after_need_more_data)
      resetForNewToken();

    Error error = Error::NeedMoreData;
    while (error == Error::NeedMoreData && data_list.size()) {
      const DataRef &json_data = data_list.front();
      error = populateNextTokenFromDataRef(next_token, json_data);

      if (error != Error::NoError && error != Error::NeedMoreData)
        updateErrorContext(error);

      if (error == Error::NeedMoreData) {
        releaseFirstDataRef();
        requestMoreData();
      }
    }

    continue_after_need_more_data = error == Error::NeedMoreData;
    if (error == JS::Error::NoError) {
      if (next_token.value_type == Type::ArrayStart || next_token.value_type == Type::ObjectStart)
        container_stack.push_back(next_token.value_type);
      if (next_token.value_type == Type::ArrayEnd) {
        if (!container_stack.size() || container_stack.back() != JS::Type::ArrayStart) {
          error = Error::UnexpectedArrayEnd;
          updateErrorContext(error);
          return error;
        }
        container_stack.pop_back();
      }
      if (next_token.value_type == Type::ObjectEnd) {
        if (!container_stack.size() || container_stack.back() != JS::Type::ObjectStart) {
          error = Error::UnexpectedObjectEnd;
          updateErrorContext(error);
          return error;
        }
        container_stack.pop_back();
      }
      if (scope_counter.size())
        scope_counter.back().handleType(next_token.value_type);
    }
    return error;
  }

  inline const char *Tokenizer::currentPosition() const {
    if (parsed_data_vector)
      return reinterpret_cast<const char *>(cursor_index);

    if (data_list.empty())
      return nullptr;

    return data_list.front().data + cursor_index;
  }

  static bool isValueInIntermediateToken(const Token &token, const Internal::IntermediateToken &intermediate) {
    if (intermediate.data.size())
      return token.value.data >= &intermediate.data[0] &&
             token.value.data < &intermediate.data[0] + intermediate.data.size();
    return false;
  }

  inline void Tokenizer::copyFromValue(const Token &token, std::string &to_buffer) {
    if (isValueInIntermediateToken(token, intermediate_token)) {
      std::string data(token.value.data, token.value.size);
      to_buffer += data;
      auto pair = std::make_pair(cursor_index, &to_buffer);
      copy_buffers.push_back(pair);
    } else {
      assert(token.value.data >= data_list.front().data &&
        token.value.data < data_list.front().data + data_list.front().size);
      ptrdiff_t index = token.value.data - data_list.front().data;
      auto pair = std::make_pair(index, &to_buffer);
      copy_buffers.push_back(pair);
    }
  }

  inline void Tokenizer::copyIncludingValue(const Token &, std::string &to_buffer) {
    auto it =
        std::find_if(copy_buffers.begin(), copy_buffers.end(),
                     [&to_buffer](const std::pair<size_t, std::string *> &pair) { return &to_buffer == pair.second; });
    assert(it != copy_buffers.end());
    assert(it->first <= cursor_index);
    if (cursor_index - it->first != 0)
      to_buffer.append(data_list.front().data + it->first, cursor_index - it->first);
    copy_buffers.erase(it);
  }

  inline void Tokenizer::pushScope(JS::Type type) {
    scope_counter.push_back({type, 1});
    if (type != Type::ArrayStart && type != Type::ObjectStart)
      scope_counter.back().depth--;
  }

  inline void Tokenizer::popScope() {
    assert(scope_counter.size() && scope_counter.back().depth == 0);
    scope_counter.pop_back();
  }

  inline JS::Error Tokenizer::goToEndOfScope(JS::Token &token) {
    JS::Error error = JS::Error::NoError;
    while (scope_counter.back().depth && error == JS::Error::NoError) {
      error = nextToken(token);
    }
    return error;
  }

  namespace Internal {
    static const char *error_strings[] = {
      "NoError",
      "NeedMoreData",
      "InvalidToken",
      "ExpectedPropertyName",
      "ExpectedDelimiter",
      "ExpectedDataToken",
      "ExpectedObjectStart",
      "ExpectedObjectEnd",
      "ExpectedArrayStart",
      "ExpectedArrayEnd",
      "UnexpectedArrayEnd",
      "UnexpectedObjectEnd",
      "IllegalPropertyName",
      "IllegalPropertyType",
      "IllegalDataValue",
      "EncounteredIllegalChar",
      "NodeNotFound",
      "MissingPropertyMember",
      "MissingFunction",
      "FailedToParseBoolean",
      "FailedToParseDouble",
      "FailedToParseFloat",
      "FailedToParseInt",
      "UnassignedRequiredMember",
      "NonContigiousMemory",
      "ScopeHasEnded",
      "KeyNotFound",
      "DuplicateInSet",
      "UnknownError",
      "UserDefinedErrors",
    };
  }

  inline std::string Tokenizer::makeErrorString() const {
    static_assert(sizeof(Internal::error_strings) / sizeof *Internal::error_strings ==
                  size_t(Error::UserDefinedErrors) + 1,
                  "Please add missing error message");

    std::string retString("Error");
    if (error_context.error < Error::UserDefinedErrors)
      retString += std::string(" ") + Internal::error_strings[int(error_context.error)];
    if (error_context.custom_message.size())
      retString += " " + error_context.custom_message;
    retString += std::string(":\n");
    for (size_t i = 0; i < error_context.lines.size(); i++) {
      retString += error_context.lines[i] + "\n";
      if (i == error_context.line) {
        std::string pointing(error_context.character + 2, ' ');
        pointing[error_context.character] = '^';
        pointing[error_context.character + 1] = '\n';
        retString += pointing;
      }
    }
    return retString;
  }

  inline void Tokenizer::setErrorContextConfig(size_t lineContext, size_t rangeContext) {
    line_context = lineContext;
    range_context = rangeContext;
  }

  inline void Tokenizer::resetForNewToken() {
    intermediate_token.clear();
    resetForNewValue();
  }

  inline void Tokenizer::resetForNewValue() {
    property_state = InPropertyState::NoStartFound;
    property_type = Type::Error;
    current_data_start = 0;
  }

  inline Error Tokenizer::findStringEnd(const DataRef &json_data, size_t *chars_ahead) {
    size_t end = cursor_index;
    while (end < json_data.size) {
      if (is_escaped) {
        is_escaped = false;
        end++;
        continue;
      }
      while (end + 4 < json_data.size) {
        unsigned char lc = Internal::lookup()[(unsigned char) json_data.data[end]];
        if (lc == Internal::StrEndOrBackSlash)
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (lc == Internal::StrEndOrBackSlash)
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (lc == Internal::StrEndOrBackSlash)
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (lc == Internal::StrEndOrBackSlash)
          break;
        end++;
      }
      if (end >= json_data.size)
        break;
      char c = json_data.data[end];
      if (c == '\\') {
        is_escaped = true;
      } else if (c == '"') {
        *chars_ahead = end + 1 - cursor_index;
        return Error::NoError;
      }
      end++;
    }
    return Error::NeedMoreData;
  }

  inline Error Tokenizer::findAsciiEnd(const DataRef &json_data, size_t *chars_ahead) {
    assert(property_type == Type::Ascii);
    size_t end = cursor_index;
    while (end < json_data.size) {
      while (end + 4 < json_data.size) {
        unsigned char lc = Internal::lookup()[(unsigned char) json_data.data[end]];
        if (!(lc & (Internal::AsciiLetters | Internal::Digits | Internal::HatUnderscoreAprostoph)))
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (!(lc & (Internal::AsciiLetters | Internal::Digits | Internal::HatUnderscoreAprostoph)))
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (!(lc & (Internal::AsciiLetters | Internal::Digits | Internal::HatUnderscoreAprostoph)))
          break;
        lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
        if (!(lc & (Internal::AsciiLetters | Internal::Digits | Internal::HatUnderscoreAprostoph)))
          break;
        end++;
      }

      char ascii_code = json_data.data[end];
      if ((ascii_code >= 'A' && ascii_code <= 'Z') || (ascii_code >= '^' && ascii_code <= 'z') ||
          (ascii_code >= '0' && ascii_code <= '9')) {
        end++;
        continue;
      } else if (ascii_code == '\0') {
        *chars_ahead = end - cursor_index;
        return Error::NeedMoreData;
      } else {
        *chars_ahead = end - cursor_index;
        return Error::NoError;
      }
    }
    return Error::NeedMoreData;
  }

  inline Error Tokenizer::findNumberEnd(const DataRef &json_data, size_t *chars_ahead) {
    size_t end = cursor_index;
    while (end + 4 < json_data.size) {
      unsigned char lc = Internal::lookup()[(unsigned char) json_data.data[end]];
      if (!(lc & (Internal::NumberEnd)))
        break;
      lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
      if (!(lc & (Internal::NumberEnd)))
        break;
      lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
      if (!(lc & (Internal::NumberEnd)))
        break;
      lc = Internal::lookup()[(unsigned char) json_data.data[++end]];
      if (!(lc & (Internal::NumberEnd)))
        break;
      end++;
    }
    while (end < json_data.size) {
      unsigned char lc = Internal::lookup()[(unsigned char) json_data.data[end]];
      if (lc & (Internal::NumberEnd)) {
        end++;
      } else {
        *chars_ahead = end - cursor_index;
        return Error::NoError;
      }
    }
    return Error::NeedMoreData;
  }

  inline Error Tokenizer::findStartOfNextValue(Type *type, const DataRef &json_data, size_t *chars_ahead) {
    assert(property_state == InPropertyState::NoStartFound);

    for (size_t current_pos = cursor_index; current_pos < json_data.size; current_pos++) {
      const char c = json_data.data[current_pos];
      unsigned char lc = Internal::lookup()[(unsigned char) c];
      if (c == '"') {
        *type = Type::String;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (c == '{') {
        *type = Type::ObjectStart;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (c == '}') {
        *type = Type::ObjectEnd;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (c == '[') {
        *type = Type::ArrayStart;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (c == ']') {
        *type = Type::ArrayEnd;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (lc & (Internal::PlusOrMinus | Internal::Digits)) {
        *type = Type::Number;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (lc & Internal::AsciiLetters) {
        *type = Type::Ascii;
        *chars_ahead = current_pos - cursor_index;
        return Error::NoError;
      } else if (lc == 0) {
        *chars_ahead = current_pos - cursor_index;
        return Error::EncounteredIllegalChar;
      }
    }
    return Error::NeedMoreData;
  }

  inline Error Tokenizer::findDelimiter(const DataRef &json_data, size_t *chars_ahead) {
    if (container_stack.empty())
      return Error::IllegalPropertyType;
    for (size_t end = cursor_index; end < json_data.size; end++) {
      const char c = json_data.data[end];
      if (c == ':') {
        if (container_stack.back() != Type::ObjectStart)
          return Error::ExpectedDelimiter;
        token_state = InTokenState::FindingData;
        *chars_ahead = end + 1 - cursor_index;
        return Error::NoError;
      } else if (c == ',') {
        if (container_stack.back() != Type::ArrayStart)
          return Error::ExpectedDelimiter;
        token_state = InTokenState::FindingName;
        *chars_ahead = end + 1 - cursor_index;
        return Error::NoError;
      } else if (c == ']') {
        if (container_stack.back() != Type::ArrayStart)
          return Error::ExpectedDelimiter;
        token_state = InTokenState::FindingName;
        *chars_ahead = end - cursor_index;
        return Error::NoError;
      } else if (!(Internal::lookup()[(unsigned char) c] & Internal::WhiteSpaceOrNull)) {
        return Error::ExpectedDelimiter;
      }
    }
    return Error::NeedMoreData;
  }

  inline Error Tokenizer::findTokenEnd(const DataRef &json_data, size_t *chars_ahead) {
    if (container_stack.empty())
      return Error::NoError;
    for (size_t end = cursor_index; end < json_data.size; end++) {
      const char c = json_data.data[end];
      if (c == ',') {
        expecting_prop_or_annonymous_data = true;
        *chars_ahead = end + 1 - cursor_index;
        return Error::NoError;
      } else if (c == ']' || c == '}') {
        *chars_ahead = end - cursor_index;
        return Error::NoError;
      } else if (c == '\n') {
        if (allow_new_lines) {
          *chars_ahead = end + 1 - cursor_index;
          return Error::NoError;
        }
      } else if (Internal::lookup()[(unsigned char) c] & Internal::WhiteSpaceOrNull) {
        continue;
      } else {
        *chars_ahead = end + 1 - cursor_index;
        return Error::InvalidToken;
      }
    }
    return Error::NeedMoreData;
  }

  inline void Tokenizer::requestMoreData() {
    need_more_data_callbacks.invokeCallbacks(*this);
  }

  inline void Tokenizer::releaseFirstDataRef() {
    if (data_list.empty())
      return;

    const DataRef &json_data = data_list.front();

    for (auto &copy_pair: copy_buffers) {
      std::string data(json_data.data + copy_pair.first, json_data.size - copy_pair.first);
      *copy_pair.second += data;
      copy_pair.first = 0;
    }

    cursor_index = 0;
    current_data_start = 0;

    const char *data_to_release = json_data.data;
    data_list.erase(data_list.begin());
    release_callbacks.invokeCallbacks(data_to_release);
  }

  inline Error Tokenizer::populateFromDataRef(DataRef &data, Type &type, const DataRef &json_data) {
    size_t diff = 0;
    Error error = Error::NoError;
    data.size = 0;
    data.data = json_data.data + cursor_index;
    if (property_state == InPropertyState::NoStartFound) {
      error = findStartOfNextValue(&type, json_data, &diff);
      if (error != Error::NoError) {
        type = Type::Error;
        return error;
      }

      data.data = json_data.data + cursor_index + diff;
      current_data_start = cursor_index + diff;
      if (type == Type::String) {
        data.data++;
        current_data_start++;
      }
      cursor_index += diff + 1;
      property_type = type;

      if (type == Type::ObjectStart || type == Type::ObjectEnd || type == Type::ArrayStart || type == Type::ArrayEnd) {
        data.size = 1;
        property_state = InPropertyState::FoundEnd;
      } else {
        property_state = InPropertyState::FindingEnd;
      }
    }

    size_t negative_size_adjustment = 0;
    if (property_state == InPropertyState::FindingEnd) {
      switch (type) {
        case Type::String:
          error = findStringEnd(json_data, &diff);
          negative_size_adjustment = 1;
          break;
        case Type::Ascii:
          error = findAsciiEnd(json_data, &diff);
          break;
        case Type::Number:
          error = findNumberEnd(json_data, &diff);
          break;
        default:
          return Error::InvalidToken;
      }

      if (error != Error::NoError) {
        return error;
      }

      cursor_index += diff;
      data.size = cursor_index - current_data_start - negative_size_adjustment;
      property_state = InPropertyState::FoundEnd;
    }

    return Error::NoError;
  }

  inline void Tokenizer::populate_annonymous_token(const DataRef &data, Type type, Token &token) {
    token.name = DataRef();
    token.name_type = Type::Ascii;
    token.value = data;
    token.value_type = type;
  }

  namespace Internal {
    static Type getType(Type type, const char *data, size_t length) {
      static const char m_null[] = "null";
      static const char m_true[] = "true";
      static const char m_false[] = "false";
      if (type != Type::Ascii)
        return type;
      if (sizeof(m_null) - 1 == length) {
        if (memcmp(m_null, data, length) == 0) {
          return Type::Null;
        } else if (memcmp(m_true, data, length) == 0) {
          return Type::Bool;
        }
      }
      if (sizeof(m_false) - 1 == length) {
        if (memcmp(m_false, data, length) == 0)
          return Type::Bool;
      }
      return Type::Ascii;
    }

    inline size_t strnlen(const char *data, size_t size) {
      auto it = std::find(data, data + size, '\0');
      return it - data;
    }
  } // namespace Internal

  inline Error Tokenizer::populateNextTokenFromDataRef(Token &next_token, const DataRef &json_data) {
    Token tmp_token;
    while (cursor_index < json_data.size) {
      size_t diff = 0;
      DataRef data;
      Type type;
      Error error;
      switch (token_state) {
        case InTokenState::FindingName:
          type = intermediate_token.name_type;
          error = populateFromDataRef(data, type, json_data);
          if (error == Error::NeedMoreData) {
            if (property_state > InPropertyState::NoStartFound) {
              intermediate_token.active = true;
              size_t to_null = Internal::strnlen(data.data, json_data.size - current_data_start);
              intermediate_token.name.append(data.data, to_null);
              if (!intermediate_token.name_type_set) {
                intermediate_token.name_type = type;
                intermediate_token.name_type_set = true;
              }
            }
            return error;
          } else if (error != Error::NoError) {
            return error;
          }

          if (intermediate_token.active) {
            intermediate_token.name.append(data.data, data.size);
            data = DataRef(intermediate_token.name);
            type = intermediate_token.name_type;
          }

          if (type == Type::ObjectEnd || type == Type::ArrayEnd || type == Type::ArrayStart || type ==
              Type::ObjectStart) {
            switch (type) {
              case Type::ObjectEnd:
              case Type::ArrayEnd:
                if (expecting_prop_or_annonymous_data && !allow_superfluous_comma) {
                  return Error::ExpectedDataToken;
                }
                populate_annonymous_token(data, type, next_token);
                token_state = InTokenState::FindingTokenEnd;
                return Error::NoError;

              case Type::ObjectStart:
              case Type::ArrayStart:
                populate_annonymous_token(data, type, next_token);
                expecting_prop_or_annonymous_data = false;
                token_state = InTokenState::FindingName;
                return Error::NoError;
              default:
                return Error::UnknownError;
            }
          } else {
            tmp_token.name = data;
          }

          tmp_token.name_type = Internal::getType(type, tmp_token.name.data, tmp_token.name.size);
          token_state = InTokenState::FindingDelimiter;
          resetForNewValue();
          break;

        case InTokenState::FindingDelimiter:
          error = findDelimiter(json_data, &diff);
          if (error != Error::NoError) {
            if (intermediate_token.active == false) {
              intermediate_token.name.append(tmp_token.name.data, tmp_token.name.size);
              intermediate_token.name_type = tmp_token.name_type;
              intermediate_token.active = true;
            }
            return error;
          }
          cursor_index += diff;
          resetForNewValue();
          expecting_prop_or_annonymous_data = false;
          if (token_state == InTokenState::FindingName) {
            populate_annonymous_token(tmp_token.name, tmp_token.name_type, next_token);
            return Error::NoError;
          } else {
            if (tmp_token.name_type != Type::String) {
              if (!allow_ascii_properties || tmp_token.name_type != Type::Ascii) {
                return Error::IllegalPropertyName;
              }
            }
          }
          break;

        case InTokenState::FindingData:
          type = intermediate_token.data_type;
          error = populateFromDataRef(data, type, json_data);
          if (error == Error::NeedMoreData) {
            if (intermediate_token.active == false) {
              intermediate_token.name.append(tmp_token.name.data, tmp_token.name.size);
              intermediate_token.name_type = tmp_token.name_type;
              intermediate_token.active = true;
            }
            if (property_state > InPropertyState::NoStartFound) {
              size_t data_length = Internal::strnlen(data.data, json_data.size - current_data_start);
              intermediate_token.data.append(data.data, data_length);
              if (!intermediate_token.data_type_set) {
                intermediate_token.data_type = type;
                intermediate_token.data_type_set = true;
              }
            }
            return error;
          } else if (error != Error::NoError) {
            return error;
          }

          if (intermediate_token.active) {
            intermediate_token.data.append(data.data, data.size);
            if (!intermediate_token.data_type_set) {
              intermediate_token.data_type = type;
              intermediate_token.data_type_set = true;
            }
            tmp_token.name = DataRef(intermediate_token.name);
            tmp_token.name_type = intermediate_token.name_type;
            data = DataRef(intermediate_token.data);
            type = intermediate_token.data_type;
          }

          tmp_token.value = data;
          tmp_token.value_type = Internal::getType(type, tmp_token.value.data, tmp_token.value.size);

          if (tmp_token.value_type == Type::Ascii && !allow_ascii_properties)
            return Error::IllegalDataValue;

          if (type == Type::ObjectStart || type == Type::ArrayStart) {
            token_state = InTokenState::FindingName;
          } else {
            token_state = InTokenState::FindingTokenEnd;
          }
          next_token = tmp_token;
          return Error::NoError;
        case InTokenState::FindingTokenEnd:
          error = findTokenEnd(json_data, &diff);
          if (error != Error::NoError) {
            return error;
          }
          cursor_index += diff;
          token_state = InTokenState::FindingName;
          break;
      }
    }
    return Error::NeedMoreData;
  }

  namespace Internal {
    struct Lines {
      size_t start;
      size_t end;
    };
  } // namespace Internal

  inline Error Tokenizer::updateErrorContext(Error error, const std::string &custom_message) {
    error_context.error = error;
    error_context.custom_message = custom_message;
    if ((!parsed_data_vector || parsed_data_vector->empty()) && data_list.empty())
      return error;

    const DataRef json_data =
        parsed_data_vector && parsed_data_vector->size()
          ? DataRef(parsed_data_vector->front().value.data,
                    size_t(parsed_data_vector->back().value.data - parsed_data_vector->front().value.data))
          : data_list.front();
    int64_t real_cursor_index = parsed_data_vector && parsed_data_vector->size()
                                  ? int64_t(parsed_data_vector->at(cursor_index).value.data - json_data.data)
                                  : int64_t(cursor_index);
    const int64_t stop_back = real_cursor_index - std::min(int64_t(real_cursor_index), int64_t(line_range_context));
    const int64_t stop_forward = std::min(real_cursor_index + int64_t(line_range_context), int64_t(json_data.size));
    std::vector<Internal::Lines> lines;
    lines.push_back({0, size_t(real_cursor_index)});
    assert(real_cursor_index <= int64_t(json_data.size));
    int64_t lines_back = 0;
    int64_t lines_forward = 0;
    int64_t cursor_back;
    int64_t cursor_forward;
    for (cursor_back = real_cursor_index - 1; cursor_back > stop_back; cursor_back--) {
      if (*(json_data.data + cursor_back) == '\n') {
        lines.front().start = size_t(cursor_back + 1);
        lines_back++;
        if (lines_back == 1)
          error_context.character = size_t(real_cursor_index - cursor_back);
        if (lines_back == int64_t(line_context)) {
          lines_back--;
          break;
        }

        lines.insert(lines.begin(), {0, size_t(cursor_back)});
      }
    }
    if (lines.front().start == 0 && cursor_back > 0)
      lines.front().start = size_t(cursor_back);
    bool add_new_line = false;
    for (cursor_forward = real_cursor_index; cursor_forward < stop_forward; cursor_forward++) {
      if (add_new_line) {
        lines.push_back({size_t(cursor_forward), 0});
        add_new_line = false;
      }
      if (*(json_data.data + cursor_forward) == '\n') {
        lines.back().end = size_t(cursor_forward);
        lines_forward++;
        if (lines_forward == int64_t(line_context))
          break;
        add_new_line = true;
      }
    }
    if (lines.back().end == 0)
      lines.back().end = size_t(cursor_forward - 1);

    if (lines.size() > 1) {
      error_context.lines.reserve(lines.size());
      for (auto &line: lines) {
        error_context.lines.push_back(std::string(json_data.data + line.start, line.end - line.start));
      }
      error_context.line = size_t(lines_back);
    } else {
      error_context.line = 0;

      int64_t left = real_cursor_index > int64_t(range_context) ? real_cursor_index - int64_t(range_context) : 0;
      int64_t right =
          real_cursor_index + int64_t(range_context) > int64_t(json_data.size)
            ? int64_t(json_data.size)
            : real_cursor_index + int64_t(range_context);
      error_context.character = size_t(real_cursor_index - left);
      error_context.lines.push_back(std::string(json_data.data + left, size_t(right - left)));
    }
    return error;
  }

  static inline JS::Error reformat(const char *data, size_t size, std::string &out,
                                   const SerializerOptions &options = SerializerOptions()) {
    Token token;
    Tokenizer tokenizer;
    tokenizer.addData(data, size);
    Error error = Error::NoError;

    Serializer serializer;
    serializer.setOptions(options);
    size_t last_pos = 0;
    auto cbref = serializer.addRequestBufferCallback([&out, &last_pos](Serializer &serializer_p) {
      size_t end = out.size();
      out.resize(end * 2);
      serializer_p.setBuffer(&out[0] + end, end);
      last_pos = end;
    });
    if (out.empty())
      out.resize(4096);
    serializer.setBuffer(&out[0], out.size());

    while (error == Error::NoError) {
      error = tokenizer.nextToken(token);
      if (error != Error::NoError)
        break;
      serializer.write(token);
    }
    out.resize(last_pos + serializer.currentBuffer().used);
    if (error == Error::NeedMoreData)
      return Error::NoError;

    return error;
  }

  static inline JS::Error reformat(const std::string &in, std::string &out,
                                   const SerializerOptions &options = SerializerOptions()) {
    return reformat(in.c_str(), in.size(), out, options);
  }

  // Tuple start
  namespace Internal {
    template<size_t...>
    struct Sequence {
      using type = Sequence;
    };

    template<typename A, typename B>
    struct Merge;

    template<size_t... Is1, size_t... Is2>
    struct Merge<Sequence<Is1...>, Sequence<Is2...> > {
      using type = Sequence<Is1..., (sizeof...(Is1) + Is2)...>;
    };

    template<size_t size>
    struct GenSequence;

    template<>
    struct GenSequence<0> {
      using type = Sequence<>;
    };

    template<>
    struct GenSequence<1> {
      using type = Sequence<0>;
    };

    template<size_t size>
    struct GenSequence {
      using type = typename Merge<typename GenSequence<size / size_t(2)>::type,
        typename GenSequence<size - size / size_t(2)>::type>::type;
    };

    template<size_t index, typename T>
    struct Element {
      constexpr Element()
        : data() {
      }

      constexpr Element(const T &t)
        : data(t) {
      }

      using type = T;
      T data;
    };

    template<typename A, typename... Bs>
    struct TupleImpl;

    template<size_t... indices, typename... Ts>
    struct TupleImpl<Sequence<indices...>, Ts...> : public Element<indices, Ts>... {
      constexpr TupleImpl()
        : Element<indices, Ts>()... {
      }

      constexpr TupleImpl(Ts... args)
        : Element<indices, Ts>(args)... {
      }
    };
  } // namespace Internal

  template<size_t I, typename... Ts>
  struct TypeAt {
    template<typename T>
    static Internal::Element<I, T> deduce(Internal::Element<I, T>);

    using tuple_impl = Internal::TupleImpl<typename Internal::GenSequence<sizeof...(Ts)>::type, Ts...>;
    using element = decltype(deduce(tuple_impl()));
    using type = typename element::type;
  };

  template<typename... Ts>
  struct Tuple {
    constexpr Tuple()
      : impl() {
    }

    constexpr Tuple(Ts... args)
      : impl(args...) {
    }

    using Seq = typename Internal::GenSequence<sizeof...(Ts)>::type;
    Internal::TupleImpl<Seq, Ts...> impl;
    static constexpr const size_t size = sizeof...(Ts);

    template<size_t Index>
    constexpr const typename TypeAt<Index, Ts...>::type &get() const {
      return static_cast<const typename TypeAt<Index, Ts...>::element &>(impl).data;
    }

    template<size_t Index>
    typename TypeAt<Index, Ts...>::type &get() {
      return static_cast<typename TypeAt<Index, Ts...>::element &>(impl).data;
    }
  };

  /// \private
  template<size_t I, typename... Ts>
  struct TypeAt<I, const Tuple<Ts...>> {
    template<typename T>
    static Internal::Element<I, T> deduce(Internal::Element<I, T>);

    using tuple_impl = Internal::TupleImpl<typename Internal::GenSequence<sizeof...(Ts)>::type, Ts...>;
    using element = decltype(deduce(tuple_impl()));
    using type = typename element::type;
  };

  /// \private
  template<size_t I, typename... Ts>
  struct TypeAt<I, Tuple<Ts...> > {
    template<typename T>
    static Internal::Element<I, T> deduce(Internal::Element<I, T>);

    using tuple_impl = Internal::TupleImpl<typename Internal::GenSequence<sizeof...(Ts)>::type, Ts...>;
    using element = decltype(deduce(tuple_impl()));
    using type = typename element::type;
  };

  /*!  \private
   */
  template<>
  struct Tuple<> {
    static constexpr const size_t size = 0;
  };

  template<typename... Ts>
  constexpr Tuple<Ts...> makeTuple(Ts... args) {
    return Tuple<Ts...>(args...);
  }

  // Tuple end

  inline SerializerOptions::SerializerOptions(Style style)

    : m_shift_size(style == Compact ? 0 : 2)
      , m_depth(0)
      , m_style(style)
      , m_convert_ascii_to_string(true)
      , m_token_delimiter(",")
      , m_value_delimiter(style == Pretty ? ": " : ":")
      , m_postfix(style == Pretty ? "\n" : "") {
  }

  inline int SerializerOptions::shiftSize() const {
    return m_shift_size;
  }

  inline void SerializerOptions::setShiftSize(unsigned char set) {
    m_shift_size = set;
  }

  inline unsigned char SerializerOptions::depth() const {
    return m_depth;
  }

  inline SerializerOptions::Style SerializerOptions::style() const {
    return m_style;
  }

  inline bool SerializerOptions::convertAsciiToString() const {
    return m_convert_ascii_to_string;
  }

  inline void SerializerOptions::setConvertAsciiToString(bool set) {
    m_convert_ascii_to_string = set;
  }

  inline void SerializerOptions::setStyle(Style style) {
    m_style = style;
    m_postfix = m_style == Pretty ? std::string("\n") : std::string("");
    m_value_delimiter = m_style == Pretty ? std::string(" : ") : std::string(":");
    setDepth(m_depth);
  }

  inline void SerializerOptions::skipDelimiter(bool skip) {
    if (skip)
      m_token_delimiter = "";
    else
      m_token_delimiter = ",";
  }

  inline void SerializerOptions::setDepth(int depth) {
    m_depth = (unsigned char) depth;
    m_prefix = m_style == Pretty ? std::string(depth * size_t(m_shift_size), ' ') : std::string();
  }

  inline const std::string &SerializerOptions::prefix() const {
    return m_prefix;
  }

  inline const std::string &SerializerOptions::tokenDelimiter() const {
    return m_token_delimiter;
  }

  inline const std::string &SerializerOptions::valueDelimiter() const {
    return m_value_delimiter;
  }

  inline const std::string &SerializerOptions::postfix() const {
    return m_postfix;
  }

  inline void SerializerBuffer::append(const char *data, size_t data_size) {
    assert(used + data_size <= size);
    memcpy(buffer + used, data, data_size);
    used += data_size;
  }

  template<size_t SIZE>
  inline void SerializerBuffer::append(const char *data) {
    assert(used + SIZE <= size);
    memcpy(buffer + used, data, SIZE);
    used += SIZE;
  }

  inline Serializer::Serializer()
    : m_first(true)
      , m_token_start(true) {
  }

  inline Serializer::Serializer(char *buffer, size_t size)
    : m_current_buffer(buffer, size)
      , m_first(true)
      , m_token_start(true) {
  }

  inline void Serializer::setBuffer(char *buffer, size_t size) {
    m_current_buffer = SerializerBuffer(buffer, size);
  }

  inline void Serializer::setOptions(const SerializerOptions &option) {
    m_option = option;
  }


  inline bool Serializer::write(const Token &in_token) {
    auto begining_literals = makeTuple(JS::Internal::makeStringLiteral("\n  "),
                                       Internal::makeStringLiteral("\n    "),
                                       Internal::makeStringLiteral("\n      "),
                                       Internal::makeStringLiteral("\n        "),
                                       Internal::makeStringLiteral("\n          "),
                                       Internal::makeStringLiteral(",\n  "),
                                       Internal::makeStringLiteral(",\n    "),
                                       Internal::makeStringLiteral(",\n      "),
                                       Internal::makeStringLiteral(",\n        "),
                                       Internal::makeStringLiteral(",\n          "));
    //auto begining_literals_compat = makeTuple( Internal::makeStringLiteral(",\""));
    const Token &token = in_token;

    bool isEnd = token.value_type == Type::ObjectEnd || token.value_type == Type::ArrayEnd;
    if (isEnd) {
      if (m_option.depth() <= 0) {
        return false;
      }
      m_option.setDepth(m_option.depth() - 1);
    }

    bool shortcut_front = false;
    if (m_option.shiftSize() == 2 && !m_first) {
      if (!m_token_start && !isEnd) {
        if (m_option.depth() == 1)
          shortcut_front = write(begining_literals.get<5>());
        else if (m_option.depth() == 2)
          shortcut_front = write(begining_literals.get<6>());
        else if (m_option.depth() == 3)
          shortcut_front = write(begining_literals.get<7>());
        else if (m_option.depth() == 4)
          shortcut_front = write(begining_literals.get<8>());
        else if (m_option.depth() == 5)
          shortcut_front = write(begining_literals.get<9>());
      } else {
        if (m_option.depth() == 1)
          shortcut_front = write(begining_literals.get<0>());
        else if (m_option.depth() == 2)
          shortcut_front = write(begining_literals.get<1>());
        else if (m_option.depth() == 3)
          shortcut_front = write(begining_literals.get<2>());
        else if (m_option.depth() == 4)
          shortcut_front = write(begining_literals.get<3>());
        else if (m_option.depth() == 5)
          shortcut_front = write(begining_literals.get<4>());
      }
    }

    if (!shortcut_front) {
      if (!m_token_start) {
        if (!isEnd) {
          if (!m_option.tokenDelimiter().empty()) {
            if (!write(Internal::makeStringLiteral(",")))
              return false;
          }
        }
      }

      if (m_first) {
        m_first = false;
      } else {
        if (!m_option.postfix().empty())
          if (!write(m_option.postfix()))
            return false;
      }


      if (!m_option.prefix().empty())
        if (!write(m_option.prefix()))
          return false;
    }
    if (token.name.size) {
      if (!write(token.name_type, token.name))
        return false;

      if (m_option.style() == SerializerOptions::Pretty) {
        if (!write(Internal::makeStringLiteral(": ")))
          return false;
      } else {
        if (!write(Internal::makeStringLiteral(":")))
          return false;
      }
    }

    if (!write(token.value_type, token.value))
      return false;

    m_token_start = (token.value_type == Type::ObjectStart || token.value_type == Type::ArrayStart);
    if (m_token_start) {
      m_option.setDepth(m_option.depth() + 1);
    }
    return true;
  }

  inline const BufferRequestCBRef Serializer::addRequestBufferCallback(std::function<void(Serializer &)> callback) {
    return m_request_buffer_callbacks.addCallback(callback);
  }

  inline const SerializerBuffer &Serializer::currentBuffer() const {
    return m_current_buffer;
  }

  inline void Serializer::askForMoreBuffers() {
    m_request_buffer_callbacks.invokeCallbacks(*this);
  }

  inline void Serializer::markCurrentSerializerBufferFull() {
    m_current_buffer = SerializerBuffer();
    askForMoreBuffers();
  }

  inline bool Serializer::writeAsString(const DataRef &data) {
    bool written;
    written = write(Internal::makeStringLiteral("\""));
    if (!written)
      return false;

    written = write(data.data, data.size);
    if (!written)
      return false;

    written = write(Internal::makeStringLiteral("\""));

    return written;
  }

  inline bool Serializer::write(Type type, const DataRef &data) {
    bool written;
    switch (type) {
      case Type::String:
        written = writeAsString(data);
        break;
      case Type::Ascii:
        if (m_option.convertAsciiToString())
          written = writeAsString(data);
        else
          written = write(data.data, data.size);
        break;
      case Type::Null:
        written = write("null", 4);
        break;
      default:
        written = write(data.data, data.size);
        break;
    }
    return written;
  }

  inline bool Serializer::write(const char *data, size_t size) {
    if (!size)
      return true;
    size_t written = 0;
    while (written < size) {
      size_t free = m_current_buffer.free();
      if (free == 0) {
        markCurrentSerializerBufferFull();
        if (!m_current_buffer.free())
          return false;
        continue;
      }
      size_t to_write = std::min(size - written, free);
      m_current_buffer.append(data + written, to_write);
      written += to_write;
    }
    return written == size;
  }

  template<size_t SIZE>
  inline bool Serializer::write(const Internal::StringLiteral<SIZE> &strLiteral) {
    if (m_current_buffer.free() < SIZE)
      return write(strLiteral.data, SIZE);

    m_current_buffer.append<SIZE>(strLiteral.data);
    return true;
  }


  template<typename T>
  struct Nullable {
    Nullable()
      : data() {
    }

    Nullable(const T &t)
      : data(t) {
    }

    Nullable(T &&t)
      : data(std::move(t)) {
    }

    Nullable(Nullable<T> &&t)
      : data(std::move(t.data)) {
    }

    Nullable(const Nullable<T> &t)
      : data(t.data) {
    }

    Nullable<T> &operator=(const T &other) {
      data = other;
      return *this;
    }

    Nullable<T> &operator=(T &&other) {
      data = std::move(other);
      return *this;
    }

    Nullable<T> &operator=(const Nullable<T> &other) {
      data = other.data;
      return *this;
    }

    Nullable<T> &operator=(Nullable<T> &&other) {
      data = std::move(other.data);
      return *this;
    }

    T data;

    T &operator()() {
      return data;
    }

    const T &operator()() const {
      return data;
    }
  };

  template<typename T>
  struct NullableChecked {
    NullableChecked()
      : data()
        , null(true) {
    }

    NullableChecked(const T &t)
      : data(t)
        , null(false) {
    }

    NullableChecked(T &&t)
      : data(std::move(t))
        , null(false) {
    }

    NullableChecked(const NullableChecked<T> &t)
      : data(t.data)
        , null(t.null) {
    }

    NullableChecked(NullableChecked<T> &&t)
      : data(std::move(t.data))
        , null(t.null) {
    }

    NullableChecked<T> &operator=(const T &other) {
      data = other;
      null = false;
      return *this;
    }

    NullableChecked<T> &operator=(T &&other) {
      data = std::move(other);
      null = false;
      return *this;
    }

    NullableChecked<T> &operator=(const NullableChecked<T> &other) {
      data = other.data;
      null = other.null;
      return *this;
    }

    NullableChecked<T> &operator=(NullableChecked<T> &&other) {
      data = std::move(other.data);
      null = other.null;
      return *this;
    }

    T &operator()() {
      return data;
    }

    const T &operator()() const {
      return data;
    }

    T data;
    bool null;
  };

  template<typename T>
  struct Optional {
    Optional()
      : data() {
    }

    Optional(const T &t)
      : data(t) {
    }

    Optional(T &&t)
      : data(std::move(t)) {
    }

    Optional(const Optional<T> &t)
      : data(t.data) {
    }

    Optional(Optional<T> &&t)
      : data(std::move(t.data)) {
    }

    Optional<T> &operator=(const T &other) {
      data = other;
      return *this;
    }

    Optional<T> &operator=(T &&other) {
      data = std::move(other);
      return *this;
    }

    Optional<T> &operator=(const Optional<T> &other) {
      data = other.data;
      return *this;
    }

    Optional<T> &operator=(Optional<T> &&other) {
      data = std::move(other.data);
      return *this;
    }

    T data;

    T &operator()() {
      return data;
    }

    const T &operator()() const {
      return data;
    }

    typedef bool IsOptionalType;
  };

  template<typename T>
  struct OptionalChecked {
    OptionalChecked()
      : data()
        , assigned(false) {
    }

    OptionalChecked(const T &t)
      : data(t)
        , assigned(true) {
    }

    OptionalChecked(T &&t)
      : data(std::move(t))
        , assigned(true) {
    }

    OptionalChecked(const OptionalChecked<T> &t)
      : data(t.data)
        , assigned(t.assigned) {
    }

    OptionalChecked(OptionalChecked<T> &&t)
      : data(std::move(t.data))
        , assigned(t.assigned) {
    }

    OptionalChecked<T> &operator=(const T &other) {
      data = other;
      assigned = true;
      return *this;
    }

    OptionalChecked<T> &operator=(T &&other) {
      data = std::move(other);
      assigned = true;
      return *this;
    }

    OptionalChecked<T> &operator=(const OptionalChecked<T> &other) {
      data = other.data;
      assigned = other.assigned;
      return *this;
    }

    OptionalChecked<T> &operator=(OptionalChecked<T> &&other) {
      data = std::move(other.data);
      assigned = other.assigned;
      return *this;
    }

    T &operator()() {
      return data;
    }

    const T &operator()() const {
      return data;
    }
#ifdef JS_STD_OPTIONAL
    std::optional<T> opt() const {
      return assigned ? std::optional<T>(data) : std::nullopt;
    }
#endif
    T data;
    bool assigned;
    typedef bool IsOptionalType;
  };

  struct SilentString {
    std::string data;
    typedef bool IsOptionalType;
  };

  template<typename T, typename A = std::allocator<T>>
  struct SilentVector {
    std::vector<T, A> data;
    typedef bool IsOptionalType;
  };

  template<typename T, typename Deleter = std::default_delete<T>>
  struct SilentUniquePtr {
    std::unique_ptr<T, Deleter> data;
    typedef bool IsOptionalType;
  };

  struct JsonObjectRef {
    DataRef ref;
  };

  struct JsonObject {
    std::string data;
  };

  struct JsonArrayRef {
    DataRef ref;
  };

  struct JsonArray {
    std::string data;
  };

  struct JsonObjectOrArrayRef {
    DataRef ref;
  };

  struct JsonObjectOrArray {
    std::string data;
  };

  struct JsonTokens {
    std::vector<JS::Token> data;
  };

  struct JsonMeta {
    JsonMeta(size_t pos, bool is_array)
      : position(pos)
        , size(1)
        , skip(1)
        , children(0)
        , complex_children(0)
        , is_array(is_array)
        , has_data(false) {
    }

    size_t position;
    uint32_t size;
    uint32_t skip;
    uint32_t children;
    uint32_t complex_children;
    bool is_array: 1;
    bool has_data: 1;
  };

  static inline std::vector<JsonMeta> metaForTokens(const JsonTokens &tokens) {
    std::vector<JsonMeta> meta;
    meta.reserve(tokens.data.size() / 4);
    std::vector<size_t> parent;
    for (size_t i = 0; i < tokens.data.size(); i++) {
      for (size_t parent_index: parent) {
        meta[parent_index].size++;
      }
      const JS::Token &token = tokens.data.at(i);
      if (token.value_type == Type::ArrayEnd || token.value_type == Type::ObjectEnd) {
        assert(parent.size());
        assert(meta[parent.back()].is_array == (token.value_type == Type::ArrayEnd));
        parent.pop_back();
      } else {
        if (parent.size())
          meta[parent.back()].children++;
      }

      if (token.value_type == Type::ArrayStart || token.value_type == Type::ObjectStart) {
        if (parent.size())
          meta[parent.back()].complex_children++;
        for (size_t parent_index: parent) {
          meta[parent_index].skip++;
        }
        meta.push_back(JsonMeta(i, token.value_type == Type::ArrayStart));
        parent.push_back(meta.size() - 1);
      } else if (token.value_type != JS::Type::ArrayEnd && token.value_type != JS::Type::ObjectEnd) {
        for (size_t parent_index: parent) {
          meta[parent_index].has_data = true;
        }
      }
    }
    assert(!parent.size()); // This assert may be triggered when JSON is invalid (e.g. when creating a DiffContext).
    return meta;
  }

  namespace Internal {
    static inline size_t findFirstChildWithData(const std::vector<JsonMeta> &meta_vec, size_t start_index) {
      const JsonMeta &meta = meta_vec[start_index];
      if (!meta.has_data)
        return size_t(-1);

      size_t skip_size = 0;
      for (uint32_t i = 0; i < meta.complex_children; i++) {
        auto &current_child = meta_vec[start_index + skip_size + 1];
        skip_size += current_child.skip;
        if (current_child.has_data)
          return i;
      }
      return size_t(-1);
    }
  } // namespace Internal

  template<typename T>
  struct IsOptionalType {
    typedef char yes[1];
    typedef char no[2];

    template<typename C>
    static constexpr yes &test_in_optional(typename C::IsOptionalType *);

    template<typename>
    static constexpr no &test_in_optional(...);

    static constexpr const bool value = sizeof(test_in_optional<T>(0)) == sizeof(yes);
  };

  /// \private
  template<typename T>
  struct IsOptionalType<std::unique_ptr<T> > {
    static constexpr const bool value = true;
  };

#ifdef JS_STD_OPTIONAL
  /// \private
  template<typename T>
  struct IsOptionalType<std::optional<T> > {
    static constexpr const bool value = true;
  };
#endif

  struct ParseContext {
    ParseContext() {
    }

    explicit ParseContext(const char *data, size_t size) {
      tokenizer.addData(data, size);
    }

    explicit ParseContext(const char *data) {
      size_t size = strlen(data);
      tokenizer.addData(data, size);
    }

    explicit ParseContext(const std::string &data) {
      tokenizer.addData(&data[0], data.size());
    }

    template<typename T>
    explicit ParseContext(const char *data, size_t size, T &to_type) {
      tokenizer.addData(data, size);
      auto this_error = parseTo(to_type);
      (void) this_error;
    }

    template<size_t SIZE>
    explicit ParseContext(const char (&data)[SIZE]) {
      tokenizer.addData(data);
    }

    template<typename T>
    Error parseTo(T &to_type);

    Error nextToken() {
      error = tokenizer.nextToken(token);
      return error;
    }

    std::string makeErrorString() const {
      if (error == Error::MissingPropertyMember) {
        if (missing_members.size() == 0) {
          return "";
        } else if (missing_members.size() == 1) {
          return std::string("JSON Object contained member not found in C++ struct/class. JSON Object member is: ") +
                 missing_members.front();
        }
        std::string member_string = missing_members.front();
        for (int i = 1; i < int(missing_members.size()); i++)
          member_string += std::string(", ") + missing_members[i];
        return std::string("JSON Object contained members not found in C++ struct/class. JSON Object members are: ") +
               member_string;
      } else if (error == Error::UnassignedRequiredMember) {
        if (unassigned_required_members.size() == 0) {
          return "";
        } else if (unassigned_required_members.size() == 1) {
          return std::string("C++ struct/class has a required member that is not present in input JSON. The unassigned "
                   "C++ member is: ") +
                 unassigned_required_members.front();
        }
        std::string required_string = unassigned_required_members.front();
        for (int i = 1; i < int(unassigned_required_members.size()); i++)
          required_string += std::string(", ") + unassigned_required_members[i];
        return std::string(
                 "C++ struct/class has required members that are not present in the input JSON. The unassigned "
                 "C++ members are: ") +
               required_string;
      }
      if (tokenizer.errorContext().error == Error::NoError && error != Error::NoError) {
        std::string retString("Error:");
        if (error <= Error::UserDefinedErrors)
          retString += Internal::error_strings[int(error)];
        else
          retString += "Unknown error";
        return retString;
      }
      return tokenizer.makeErrorString();
    }

    Tokenizer tokenizer;
    Token token;
    Error error = Error::NoError;
    std::vector<std::string> missing_members;
    std::vector<std::string> unassigned_required_members;
    bool allow_missing_members = true;
    bool allow_unasigned_required_members = true;
    bool track_member_assignement_state = true;
    void *user_data = nullptr;
  };

  /*! \def JS_MEMBER
   *
   * Create meta information of the member with the same name as
   * the member.
   */
  /*! \def JS_MEMBER_ALIASES
   *
   * Create meta information where the primary name is the same as the member and
   * the subsequent names are aliases.
   */
  /*! \def JS_MEMBER_WITH_NAME
   *
   * Create meta information where the primary name is argument name, and the subsequent
   * names are aliases.
   */
  /*! \def JS_MEMBER_WITH_NAME_AND_ALIASES
   *
   * Creates meta information where the primary name is argument name, a
   * and subsequent names are aliases
   */

  /*! \def JS_SUPER_CLASS
   *
   * Creates superclass meta data which is used inside the JS_SUPER_CLASSES macro
   */

  /*! \def JS_SUPER_CLASSES
   *
   * Macro to contain the super class definitions
   */

  namespace Internal {
    template<typename T>
    struct HasJsonStructBase {
      typedef char yes[1];
      typedef char no[2];

      template<typename C>
      static constexpr yes &test_in_base(typename C::template JsonStructBase<C> *);

      template<typename>
      static constexpr no &test_in_base(...);
    };

    template<typename JS_BASE_STRUCT_T, typename JS_OBJECT_T>
    struct JsonStructBaseDummy {
      static_assert(sizeof(HasJsonStructBase<JS_OBJECT_T>::template test_in_base<JS_OBJECT_T>(nullptr)) ==
                    sizeof(typename HasJsonStructBase<JS_OBJECT_T>::yes),
                    "Missing JS_OBJECT JS_OBJECT_EXTERNAL or TypeHandler specialisation\n");
      using TT = decltype(JS_OBJECT_T::template JsonStructBase<JS_OBJECT_T>::js_static_meta_data_info());
      using ST = decltype(JS_OBJECT_T::template JsonStructBase<JS_OBJECT_T>::js_static_meta_super_info());

      static inline constexpr const TT js_static_meta_data_info() {
        return JS_OBJECT_T::template JsonStructBase<JS_OBJECT_T>::js_static_meta_data_info();
      }

      static inline constexpr const ST js_static_meta_super_info() {
        return JS_OBJECT_T::template JsonStructBase<JS_OBJECT_T>::js_static_meta_super_info();
      }
    };
  } // namespace Internal

#define JS_INTERNAL_EXPAND(x) x
#define JS_INTERNAL_FIRST_(a, ...) a
#define JS_INTERNAL_SECOND_(a, b, ...) b
#define JS_INTERNAL_FIRST(...) JS_INTERNAL_EXPAND(JS_INTERNAL_FIRST_(__VA_ARGS__))
#define JS_INTERNAL_SECOND(...) JS_INTERNAL_EXPAND(JS_INTERNAL_SECOND_(__VA_ARGS__))
#define JS_INTERNAL_EMPTY()
#define JS_INTERNAL_EVAL(...) JS_INTERNAL_EVAL1024(__VA_ARGS__)
#define JS_INTERNAL_EVAL1024(...) JS_INTERNAL_EVAL512(JS_INTERNAL_EVAL512(__VA_ARGS__))
#define JS_INTERNAL_EVAL512(...) JS_INTERNAL_EVAL256(JS_INTERNAL_EVAL256(__VA_ARGS__))
#define JS_INTERNAL_EVAL256(...) JS_INTERNAL_EVAL128(JS_INTERNAL_EVAL128(__VA_ARGS__))
#define JS_INTERNAL_EVAL128(...) JS_INTERNAL_EVAL64(JS_INTERNAL_EVAL64(__VA_ARGS__))
#define JS_INTERNAL_EVAL64(...) JS_INTERNAL_EVAL32(JS_INTERNAL_EVAL32(__VA_ARGS__))
#define JS_INTERNAL_EVAL32(...) JS_INTERNAL_EVAL16(JS_INTERNAL_EVAL16(__VA_ARGS__))
#define JS_INTERNAL_EVAL16(...) JS_INTERNAL_EVAL8(JS_INTERNAL_EVAL8(__VA_ARGS__))
#define JS_INTERNAL_EVAL8(...) JS_INTERNAL_EVAL4(JS_INTERNAL_EVAL4(__VA_ARGS__))
#define JS_INTERNAL_EVAL4(...) JS_INTERNAL_EVAL2(JS_INTERNAL_EVAL2(__VA_ARGS__))
#define JS_INTERNAL_EVAL2(...) JS_INTERNAL_EVAL1(JS_INTERNAL_EVAL1(__VA_ARGS__))
#define JS_INTERNAL_EVAL1(...) __VA_ARGS__

#define JS_INTERNAL_DEFER1(m) m JS_INTERNAL_EMPTY()
#define JS_INTERNAL_DEFER2(m) m JS_INTERNAL_EMPTY JS_INTERNAL_EMPTY()()

#define JS_INTERNAL_IS_PROBE(...) JS_INTERNAL_SECOND(__VA_ARGS__, 0, 0)
#define JS_INTERNAL_PROBE() ~, 1

#define JS_INTERNAL_CAT(a, b) a##b

#define JS_INTERNAL_NOT(x) JS_INTERNAL_IS_PROBE(JS_INTERNAL_CAT(JS_INTERNAL__NOT_, x))
#define JS_INTERNAL__NOT_0 JS_INTERNAL_PROBE()

#define JS_INTERNAL_BOOL(x) JS_INTERNAL_NOT(JS_INTERNAL_NOT(x))

#define JS_INTERNAL_IF_ELSE(condition) JS_INTERNAL__IF_ELSE(JS_INTERNAL_BOOL(condition))
#define JS_INTERNAL__IF_ELSE(condition) JS_INTERNAL_CAT(JS_INTERNAL__IF_, condition)

#define JS_INTERNAL__IF_1(...) __VA_ARGS__ JS_INTERNAL__IF_1_ELSE
#define JS_INTERNAL__IF_0(...) JS_INTERNAL__IF_0_ELSE

#define JS_INTERNAL__IF_1_ELSE(...)
#define JS_INTERNAL__IF_0_ELSE(...) __VA_ARGS__

#define JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(...)                                                                        \
  JS_INTERNAL_BOOL(JS_INTERNAL_SECOND(JS_INTERNAL__END_OF_ARGUMENTS_ __VA_ARGS__, 0, 0)())
#define JS_INTERNAL__END_OF_ARGUMENTS_() 0

#define JS_MEMBER(member) JS::makeMemberInfo(#member, &JS_OBJECT_T::member)
#define JS_MEMBER_ALIASES(member, ...)                                                                                 \
  JS_INTERNAL_EXPAND(JS::makeMemberInfo(#member, &JS_OBJECT_T::member, __VA_ARGS__))
#define JS_MEMBER_WITH_NAME(member, name) JS::makeMemberInfo(name, &JS_OBJECT_T::member)
#define JS_MEMBER_WITH_NAME_AND_ALIASES(member, name, ...) JS::makeMemberInfo(name, &JS_OBJECT_T::member, __VA_ARGS__)

#define JS_SUPER_CLASS(super) JS::makeSuperInfo<super>(#super)

#define JS_SUPER_CLASSES(...) JS::makeTuple(__VA_ARGS__)
#define JS_INTERNAL__MAP_MEMBER() JS_INTERNAL_MAP_MEMBER

#define JS_INTERNAL_MAKE_MEMBERS(...)                                                                                  \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (JS_INTERNAL_EXPAND(JS_INTERNAL_EVAL(JS_INTERNAL_MAP_MEMBER(JS::makeMemberInfo, __VA_ARGS__))))(                     \
    JS_INTERNAL_MAP_APPLY_MEMBER(JS::makeMemberInfo, __VA_ARGS__))

#define JS_INTERNAL_MAP_APPLY_MEMBER(m, first) m(#first, &JS_OBJECT_T::first)

#define JS_INTERNAL_MAP_MEMBER(m, first, ...)                                                                          \
  JS_INTERNAL_MAP_APPLY_MEMBER(m, first)                                                                               \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (, JS_INTERNAL_DEFER2(JS_INTERNAL__MAP_MEMBER)()(m, __VA_ARGS__))(, JS_INTERNAL_MAP_APPLY_MEMBER(m, __VA_ARGS__))

#define JS_INTERNAL_MAP_APPLY_SUPER(m, first) m<first>(#first)

#define JS_INTERNAL_MAP_SUPER(m, first, ...)                                                                           \
  JS_INTERNAL_MAP_APPLY_SUPER(m, first)                                                                                \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (, JS_INTERNAL_DEFER2(JS_INTERNAL__MAP_SUPER)()(m, __VA_ARGS__))(, JS_INTERNAL_MAP_APPLY_SUPER(m, __VA_ARGS__))

#define JS_INTERNAL__MAP_SUPER() JS_INTERNAL_MAP_SUPER

#define JS_INTERNAL_MAKE_SUPER_CLASSES(...)                                                                            \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (JS_INTERNAL_EXPAND(JS_INTERNAL_EVAL(JS_INTERNAL_MAP_SUPER(JS::makeSuperInfo, __VA_ARGS__))))(                       \
    JS_INTERNAL_MAP_APPLY_SUPER(JS::makeSuperInfo, __VA_ARGS__))

#define JS_SUPER(...) JS::makeTuple(JS_INTERNAL_EXPAND(JS_INTERNAL_MAKE_SUPER_CLASSES(__VA_ARGS__)))

#define JS_OBJECT_INTERNAL_IMPL(super_list, member_list)                                                               \
  template <typename JS_OBJECT_T>                                                                                      \
  struct JsonStructBase                                                                                                \
  {                                                                                                                    \
    using TT = decltype(member_list);                                                                                  \
    static inline constexpr const TT js_static_meta_data_info()                                                        \
    {                                                                                                                  \
      return member_list;                                                                                              \
    }                                                                                                                  \
    static inline constexpr const decltype(super_list) js_static_meta_super_info()                                     \
    {                                                                                                                  \
      return super_list;                                                                                               \
    }                                                                                                                  \
  }

#define JS_OBJECT_EXTERNAL_INTERNAL_IMPL(Type, super_list, member_list)                                                \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  namespace Internal                                                                                                   \
  {                                                                                                                    \
  template <typename JS_OBJECT_T>                                                                                      \
  struct JsonStructBaseDummy<Type, JS_OBJECT_T>                                                                        \
  {                                                                                                                    \
    using TT = decltype(member_list);                                                                                  \
    static constexpr const TT js_static_meta_data_info()                                                               \
    {                                                                                                                  \
      return member_list;                                                                                              \
    }                                                                                                                  \
    static constexpr const decltype(super_list) js_static_meta_super_info()                                            \
    {                                                                                                                  \
      return super_list;                                                                                               \
    }                                                                                                                  \
  };                                                                                                                   \
  }                                                                                                                    \
  }

#define JS_OBJECT(...) JS_OBJECT_INTERNAL_IMPL(JS::makeTuple(), JS::makeTuple(__VA_ARGS__))
#define JS_OBJECT_WITH_SUPER(super_list, ...) JS_OBJECT_INTERNAL_IMPL(super_list, JS::makeTuple(__VA_ARGS__))

#define JS_OBJECT_EXTERNAL(Type, ...)                                                                                  \
  JS_OBJECT_EXTERNAL_INTERNAL_IMPL(Type, JS::makeTuple(), JS::makeTuple(__VA_ARGS__))
#define JS_OBJECT_EXTERNAL_WITH_SUPER(Type, super_list, ...)                                                           \
  JS_OBJECT_EXTERNAL_INTERNAL_IMPL(Type, super_list, JS::makeTuple(__VA_ARGS__))

#define JS_OBJ(...) JS_OBJECT_INTERNAL_IMPL(JS::makeTuple(), JS::makeTuple(JS_INTERNAL_MAKE_MEMBERS(__VA_ARGS__)))
#define JS_OBJ_SUPER(super_list, ...)                                                                                  \
  JS_OBJECT_INTERNAL_IMPL(super_list, JS::makeTuple(JS_INTERNAL_MAKE_MEMBERS(__VA_ARGS__)))

#define JS_OBJ_EXT(Type, ...)                                                                                          \
  JS_OBJECT_EXTERNAL_INTERNAL_IMPL(Type, JS::makeTuple(), JS::makeTuple(JS_INTERNAL_MAKE_MEMBERS(__VA_ARGS__)))
#define JS_OBJ_EXT_SUPER(Type, super_list, ...)                                                                        \
  JS_OBJECT_EXTERNAL_INTERNAL_IMPL(Type, super_list, JS::makeTuple(JS_INTERNAL_MAKE_MEMBERS(__VA_ARGS__)))

  /*!
   * \private
   */
  template<typename T, typename U, typename NAMETUPLE>
  struct MI {
    NAMETUPLE names;
    T U::*member;
    typedef T type;
  };

  namespace Internal {
    template<typename T, typename U, typename NAMETUPLE>
    using MemberInfo = MI<T, U, NAMETUPLE>;

    template<typename T>
    struct SuperInfo {
      constexpr explicit SuperInfo()
        : name() {
      }

      constexpr explicit SuperInfo(const DataRef &name)
        : name(name) {
      }

      const DataRef name;
      typedef T type;
    };
  } // namespace Internal

  template<typename T, typename U, size_t NAME_SIZE, typename... Aliases>
  constexpr auto makeMemberInfo(const char (&name)[NAME_SIZE], T U::*member, Aliases &... aliases)
    -> MI<T, U, decltype(makeTuple(JS::Internal::makeStringLiteral(name),
                                   JS::Internal::makeStringLiteral(aliases)...))> {
    return {makeTuple(JS::Internal::makeStringLiteral(name), JS::Internal::makeStringLiteral(aliases)...), member};
  }

  template<typename T, size_t NAME_SIZE>
  constexpr const Internal::SuperInfo<T> makeSuperInfo(const char (&name)[NAME_SIZE]) {
    return Internal::SuperInfo<T>(DataRef(name));
  }

  template<typename T, typename Enable = void>
  struct TypeHandler {
    static inline Error to(T &to_type, ParseContext &context);

    static inline void from(const T &from_type, Token &token, Serializer &serializer);
  };

  namespace Internal {
    template<size_t STRINGSIZE>
    inline bool compareDataRefWithStringLiteral(const StringLiteral<STRINGSIZE> &memberName, const DataRef &jsonName) {
      return jsonName.size == STRINGSIZE && memcmp(memberName.data, jsonName.data, STRINGSIZE) == 0;
    }

    template<typename NameTuple, size_t index>
    struct NameChecker {
      static bool compare(const NameTuple &tuple, const DataRef &name) {
        JS_IF_CONSTEXPR(index != NameTuple::size) {
          auto &stringLiteral = tuple.template get<NameTuple::size - index>();
          if (compareDataRefWithStringLiteral(stringLiteral, name))
            return true;
        }
        return NameChecker<NameTuple, index - 1>::compare(tuple, name);
      }
    };

    template<typename NameTuple>
    struct NameChecker<NameTuple, 0> {
      static bool compare(const NameTuple &tuple, const DataRef &name) {
        JS_UNUSED(tuple);
        JS_UNUSED(name);
        return false;
      }
    };

    template<typename T, typename MI_T, typename MI_M, typename MI_NC>
    inline Error unpackMember(T &to_type, const MemberInfo<MI_T, MI_M, MI_NC> &memberInfo, ParseContext &context,
                              size_t index, bool primary, bool *assigned_members) {
      if (primary) {
        if (compareDataRefWithStringLiteral(memberInfo.names.template get<0>(), context.token.name)) {
          assigned_members[index] = true;
          return TypeHandler<MI_T>::to(to_type.*memberInfo.member, context);
        }
      } else {
        if (NameChecker<MI_NC, MI_NC::size>::compare(memberInfo.names, context.token.name)) {
          assigned_members[index] = true;
          return TypeHandler<MI_T>::to(to_type.*memberInfo.member, context);
        }
      }
      return Error::MissingPropertyMember;
    }

    template<typename MI_T, typename MI_M, typename MI_NC>
    inline Error verifyMember(const MemberInfo<MI_T, MI_M, MI_NC> &memberInfo, size_t index, bool *assigned_members,
                              bool track_missing_members, std::vector<std::string> &missing_members,
                              const char *super_name) {
      if (assigned_members[index])
        return Error::NoError;
      if (IsOptionalType<MI_T>::value)
        return Error::NoError;

      if (track_missing_members) {
        std::string to_push = strlen(super_name) ? std::string(super_name) + "::" : std::string();
        to_push += std::string(memberInfo.names.template get<0>().data, memberInfo.names.template get<0>().size);
        missing_members.push_back(to_push);
      }
      return Error::UnassignedRequiredMember;
    }

    template<typename T, typename MI_T, typename MI_M, typename MI_NC>
    inline void serializeMember(const T &from_type, const MemberInfo<MI_T, MI_M, MI_NC> &memberInfo, Token &token,
                                Serializer &serializer, const char *super_name) {
      JS_UNUSED(super_name);
      token.name.data = memberInfo.names.template get<0>().data;
      token.name.size = memberInfo.names.template get<0>().size;
      token.name_type = Type::Ascii;

      TypeHandler<MI_T>::from(from_type.*memberInfo.member, token, serializer);
    }

    template<typename T, size_t PAGE, size_t INDEX>
    struct SuperClassHandler {
      static Error handleSuperClasses(T &to_type, ParseContext &context, bool primary, bool *assigned_members);

      static Error verifyMembers(bool *assigned_members, bool track_missing_members,
                                 std::vector<std::string> &missing_members);

      static constexpr size_t membersInSuperClasses();

      static void serializeMembers(const T &from_type, Token &token, Serializer &serializer);
    };

    template<typename T, size_t PAGE, size_t SIZE>
    struct StartSuperRecursion {
      static Error start(T &to_type, ParseContext &context, bool primary, bool *assigned) {
        return SuperClassHandler<T, PAGE, SIZE - 1>::handleSuperClasses(to_type, context, primary, assigned);
      }

      static Error verifyMembers(bool *assigned_members, bool track_missing_members,
                                 std::vector<std::string> &missing_members) {
        return SuperClassHandler<T, PAGE, SIZE - 1>::verifyMembers(assigned_members, track_missing_members,
                                                                   missing_members);
      }

      static constexpr size_t membersInSuperClasses() {
        return SuperClassHandler<T, PAGE, SIZE - 1>::membersInSuperClasses();
      }

      static void serializeMembers(const T &from_type, Token &token, Serializer &serializer) {
        return SuperClassHandler<T, PAGE, SIZE - 1>::serializeMembers(from_type, token, serializer);
      }
    };

    template<typename T, size_t PAGE>
    constexpr size_t memberCount() {
      using Members = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_data_info());
      using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
      return Members::size + StartSuperRecursion<T, PAGE + Members::size, SuperMeta::size>::membersInSuperClasses();
    }

    template<typename T, size_t PAGE>
    struct StartSuperRecursion<T, PAGE, 0> {
      static Error start(T &to_type, ParseContext &context, bool primary, bool *assigned) {
        JS_UNUSED(to_type);
        JS_UNUSED(context);
        JS_UNUSED(primary);
        JS_UNUSED(assigned);
        return Error::MissingPropertyMember;
      }

      static Error verifyMembers(bool *assigned_members, bool track_missing_members,
                                 std::vector<std::string> &missing_members) {
        JS_UNUSED(assigned_members);
        JS_UNUSED(track_missing_members);
        JS_UNUSED(missing_members);
        return Error::NoError;
      }

      static constexpr size_t membersInSuperClasses() {
        return 0;
      }

      static void serializeMembers(const T &from_type, Token &token, Serializer &serializer) {
        JS_UNUSED(from_type);
        JS_UNUSED(token);
        JS_UNUSED(serializer);
      }
    };

    template<typename T, typename Members, size_t PAGE, size_t INDEX>
    struct MemberChecker {
      inline static Error unpackMembers(T &to_type, const Members &members, ParseContext &context, bool primary,
                                        bool *assigned_members) {
        Error error =
            unpackMember(to_type, members.template get<INDEX>(), context, PAGE + INDEX, primary, assigned_members);
        if (error != Error::MissingPropertyMember)
          return error;

        return MemberChecker<T, Members, PAGE, INDEX - 1>::unpackMembers(to_type, members, context, primary,
                                                                         assigned_members);
      }

      inline static Error verifyMembers(const Members &members, bool *assigned_members, bool track_missing_members,
                                        std::vector<std::string> &missing_members, const char *super_name) {
        Error memberError = verifyMember(members.template get<INDEX>(), PAGE + INDEX, assigned_members,
                                         track_missing_members, missing_members, super_name);
        Error error = MemberChecker<T, Members, PAGE, INDEX - 1>::verifyMembers(
          members, assigned_members, track_missing_members, missing_members, super_name);
        if (memberError != Error::NoError)
          return memberError;
        return error;
      }

      inline static void serializeMembers(const T &from_type, const Members &members, Token &token,
                                          Serializer &serializer,
                                          const char *super_name) {
        serializeMember(from_type, members.template get<Members::size - INDEX - 1>(), token, serializer, super_name);
        MemberChecker<T, Members, PAGE, INDEX - 1>::serializeMembers(from_type, members, token, serializer, super_name);
      }
    };

    template<typename T, typename Members, size_t PAGE>
    struct MemberChecker<T, Members, PAGE, 0> {
      inline static Error unpackMembers(T &to_type, const Members &members, ParseContext &context, bool primary,
                                        bool *assigned_members) {
        Error error = unpackMember(to_type, members.template get<0>(), context, PAGE, primary, assigned_members);
        if (error != Error::MissingPropertyMember)
          return error;

        using Super = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        return StartSuperRecursion<T, PAGE + Members::size, Super::size>::start(to_type, context, primary,
          assigned_members);
      }

      inline static Error verifyMembers(const Members &members, bool *assigned_members, bool track_missing_members,
                                        std::vector<std::string> &missing_members, const char *super_name) {
        Error memberError = verifyMember(members.template get<0>(), PAGE, assigned_members, track_missing_members,
                                         missing_members, super_name);
        using Super = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        Error superError = StartSuperRecursion<T, PAGE + Members::size, Super::size>::verifyMembers(
          assigned_members, track_missing_members, missing_members);
        if (memberError != Error::NoError)
          return memberError;
        return superError;
      }

      inline static void serializeMembers(const T &from_type, const Members &members, Token &token,
                                          Serializer &serializer,
                                          const char *super_name) {
        serializeMember(from_type, members.template get<Members::size - 1>(), token, serializer, super_name);
        using Super = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        StartSuperRecursion<T, PAGE + Members::size, Super::size>::serializeMembers(from_type, token, serializer);
      }
    };

    template<typename T, size_t PAGE, size_t INDEX>
    Error SuperClassHandler<T, PAGE, INDEX>::handleSuperClasses(T &to_type, ParseContext &context, bool primary,
                                                                bool *assigned_members) {
      using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
      using Super = typename JS::TypeAt<INDEX, SuperMeta>::type::type;
      using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
      auto members = Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
      Error error = MemberChecker<Super, Members, PAGE, Members::size - 1>::unpackMembers(
        static_cast<Super &>(to_type), members, context, primary, assigned_members);
      if (error != Error::MissingPropertyMember)
        return error;
      return SuperClassHandler<T, PAGE + memberCount<Super, 0>(), INDEX - 1>::handleSuperClasses(
        to_type, context, primary,
        assigned_members);
    }

    template<typename T, size_t PAGE, size_t INDEX>
    Error SuperClassHandler<T, PAGE, INDEX>::verifyMembers(bool *assigned_members, bool track_missing_members,
                                                           std::vector<std::string> &missing_members) {
      using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
      using Super = typename TypeAt<INDEX, SuperMeta>::type::type;
      using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
      auto members = Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
      const char *super_name =
          Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info().template get<INDEX>().name.data;
      Error error = MemberChecker<Super, Members, PAGE, Members::size - 1>::verifyMembers(
        members, assigned_members, track_missing_members, missing_members, super_name);
      Error superError = SuperClassHandler<T, PAGE + memberCount<Super, 0>(), INDEX - 1>::verifyMembers(
        assigned_members, track_missing_members, missing_members);
      if (error != Error::NoError)
        return error;
      return superError;
    }

    template<typename T, size_t PAGE, size_t INDEX>
    size_t constexpr SuperClassHandler<T, PAGE, INDEX>::membersInSuperClasses() {
      using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
      using Super = typename TypeAt<INDEX, SuperMeta>::type::type;
      return memberCount<Super, PAGE>() +
             SuperClassHandler<T, PAGE + memberCount<Super, PAGE>(), INDEX - 1>::membersInSuperClasses();
    }

    template<typename T, size_t PAGE, size_t INDEX>
    void SuperClassHandler<T, PAGE, INDEX>::serializeMembers(const T &from_type, Token &token, Serializer &serializer) {
      using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
      using Super = typename TypeAt<INDEX, SuperMeta>::type::type;
      using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
      auto members = Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
      MemberChecker<Super, Members, PAGE, Members::size - 1>::serializeMembers(
        from_type, members, token, serializer, "");
      SuperClassHandler<T, PAGE + memberCount<Super, 0>(), INDEX - 1>::serializeMembers(from_type, token, serializer);
    }

    template<typename T, size_t PAGE>
    struct SuperClassHandler<T, PAGE, 0> {
      static Error handleSuperClasses(T &to_type, ParseContext &context, bool primary, bool *assigned_members) {
        using Meta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        using Super = typename TypeAt<0, Meta>::type::type;
        using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
        auto members = Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
        return MemberChecker<Super, Members, PAGE, Members::size - 1>::unpackMembers(
          static_cast<Super &>(to_type), members,
          context, primary, assigned_members);
      }

      static Error verifyMembers(bool *assigned_members, bool track_missing_members,
                                 std::vector<std::string> &missing_members) {
        using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        using Super = typename TypeAt<0, SuperMeta>::type::type;
        using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
        auto members = Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
        const char *super_name =
            Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info().template get<0>().name.data;
        return MemberChecker<Super, Members, PAGE, Members::size - 1>::verifyMembers(
          members, assigned_members, track_missing_members, missing_members, super_name);
      }

      constexpr static size_t membersInSuperClasses() {
        using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        using Super = typename TypeAt<0, SuperMeta>::type::type;
        return memberCount<Super, PAGE>();
      }

      static void serializeMembers(const T &from_type, Token &token, Serializer &serializer) {
        using SuperMeta = decltype(Internal::template JsonStructBaseDummy<T, T>::js_static_meta_super_info());
        using Super = typename TypeAt<0, SuperMeta>::type::type;
        using Members = decltype(Internal::template JsonStructBaseDummy<Super, Super>::js_static_meta_data_info());
        auto members = Internal::JsonStructBaseDummy<Super, Super>::js_static_meta_data_info();
        MemberChecker<Super, Members, PAGE, Members::size - 1>::serializeMembers(
          from_type, members, token, serializer, "");
      }
    };

    static bool skipArrayOrObject(ParseContext &context) {
      assert(context.error == Error::NoError);
      Type start_type = context.token.value_type;
      Type end_type;
      if (context.token.value_type == Type::ObjectStart) {
        end_type = Type::ObjectEnd;
      } else if (context.token.value_type == Type::ArrayStart) {
        end_type = Type::ArrayEnd;
      } else {
        return false;
      }

      int depth = 1;
      while (depth > 0) {
        context.nextToken();
        if (context.error != Error::NoError) {
          return false;
        }
        if (context.token.value_type == start_type) {
          depth++;
        } else if (context.token.value_type == end_type) {
          depth--;
        }
      }

      return context.token.value_type == end_type && context.error == Error::NoError;
    }
  } // namespace Internal

  template<typename T>
  JS_NODISCARD inline Error ParseContext::parseTo(T &to_type) {
    missing_members.reserve(10);
    unassigned_required_members.reserve(10);
    error = tokenizer.nextToken(token);
    if (error != JS::Error::NoError)
      return error;
    error = TypeHandler<T>::to(to_type, *this);
    if (error != JS::Error::NoError && tokenizer.errorContext().error == JS::Error::NoError) {
      tokenizer.updateErrorContext(error);
    }
    return error;
  }

  struct SerializerContext {
    SerializerContext(std::string &json_out_p)
      : serializer()
        , cb_ref(serializer.addRequestBufferCallback([this](Serializer &serializer_p) {
          size_t end = this->json_out.size();
          this->json_out.resize(end * 2);
          serializer_p.setBuffer(&(this->json_out[0]) + end, end);
          this->last_pos = end;
        }))
        , json_out(json_out_p)
        , last_pos(0) {
      if (json_out.empty())
        json_out.resize(4096);
      serializer.setBuffer(&json_out[0], json_out.size());
    }

    ~SerializerContext() {
      flush();
    }

    template<typename T>
    void serialize(const T &type) {
      JS::Token token;
      JS::TypeHandler<T>::from(type, token, serializer);
      flush();
    }

    void flush() {
      json_out.resize(last_pos + serializer.currentBuffer().used);
    }

    Serializer serializer;
    BufferRequestCBRef cb_ref;
    std::string &json_out;
    size_t last_pos;
  };

  template<typename T>
  JS_NODISCARD std::string serializeStruct(const T &from_type) {
    std::string ret_string;
    SerializerContext serializeContext(ret_string);
    Token token;
    TypeHandler<T>::from(from_type, token, serializeContext.serializer);
    serializeContext.flush();
    return ret_string;
  }

  template<typename T>
  JS_NODISCARD std::string serializeStruct(const T &from_type, const SerializerOptions &options) {
    std::string ret_string;
    SerializerContext serializeContext(ret_string);
    serializeContext.serializer.setOptions(options);
    Token token;
    TypeHandler<T>::from(from_type, token, serializeContext.serializer);
    serializeContext.flush();
    return ret_string;
  }

  template<>
  struct TypeHandler<Error> {
    static inline Error to(Error &to_type, ParseContext &context) {
      (void) to_type;
      (void) context;
      //		if (context.token.value_type == JS::Type::Number) {
      //			int x;
      //			Error error = TypeHandler<int>::to(x, context);
      //			for (int i = 0; i < )
      //		}

      //        size_t level = 1;
      //        Error error = Error::NoError;
      //        while (error == JS::Error::NoError && level) {
      //            error = context.nextToken();
      //            if (context.token.value_type == Type::ObjectStart)
      //                level++;
      //            else if (context.token.value_type == Type::ObjectEnd)
      //                level--;
      //        }

      //        context.tokenizer.copyIncludingValue(context.token, to_type.data);

      return Error::NoError;
    }

    static inline void from(const Error &from_type, Token &token, Serializer &serializer) {
      token.value_type = JS::Type::String;
      if (from_type < JS::Error::UserDefinedErrors) {
        token.value = DataRef(Internal::error_strings[(int) from_type]);
      } else {
        token.value = DataRef("UserDefinedError");
      }
      serializer.write(token);
    }
  };

  struct CallFunctionExecutionState {
    explicit CallFunctionExecutionState(const std::string &name)
      : name(name)
        , error(Error::NoError) {
    }

    std::string name;
    SilentString context;
    Error error;
    SilentString error_string;
    SilentVector<std::string> missing_members;
    SilentVector<std::string> unassigned_required_members;
    SilentVector<CallFunctionExecutionState> child_states;
    JS_OBJECT(JS_MEMBER(name), JS_MEMBER(context), JS_MEMBER(error), JS_MEMBER(error_string),
              JS_MEMBER(missing_members),
              JS_MEMBER(unassigned_required_members), JS_MEMBER(child_states));
  };

  struct CallFunctionContext;

  struct CallFunctionErrorContext {
    CallFunctionErrorContext(CallFunctionContext &context)
      : context(context) {
    }

    Error setError(Error error, const std::string &error_string);

    Error setError(const std::string &error_string) {
      return setError(Error::UserDefinedErrors, error_string);
    }

    Error getLatestError() const;

  private:
    CallFunctionContext &context;
  };

  struct CallFunctionContext {
    CallFunctionContext(ParseContext &parser_context, Serializer &return_serializer)
      : parse_context(parser_context)
        , return_serializer(return_serializer)
        , error_context(*this) {
    }

    virtual ~CallFunctionContext() {
    }

    template<typename T>
    Error callFunctions(T &container);

    ParseContext &parse_context;
    Serializer &return_serializer;
    CallFunctionErrorContext error_context;
    std::vector<CallFunctionExecutionState> execution_list;
    std::string user_context;
    bool allow_missing = false;
    bool stop_execute_on_fail = false;
    void *user_handle = nullptr;

  protected:
    virtual void beforeCallFunctions() {
    }

    virtual void afterCallFunctions() {
    }
  };

  inline Error CallFunctionErrorContext::setError(Error error, const std::string &errorString) {
    context.parse_context.error = error;
    if (context.execution_list.size()) {
      context.execution_list.back().error = error;
      context.execution_list.back().error_string.data = context.parse_context.tokenizer.makeErrorString();
    }
    context.parse_context.tokenizer.updateErrorContext(error, errorString);
    return error;
  }

  inline Error CallFunctionErrorContext::getLatestError() const {
    return context.parse_context.error;
  }

  template<typename T, typename Ret, typename Arg, size_t NAME_COUNT, size_t TAKES_CONTEXT>
  struct FunctionInfo {
    typedef Ret (T::*Function)(Arg);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, typename Arg, size_t NAME_COUNT>
  struct FunctionInfo<T, Ret, Arg, NAME_COUNT, 1> {
    typedef Ret (T::*Function)(Arg, CallFunctionErrorContext &);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, typename Arg, size_t NAME_COUNT>
  struct FunctionInfo<T, Ret, Arg, NAME_COUNT, 2> {
    typedef Ret (T::*Function)(Arg, CallFunctionContext &);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, size_t NAME_COUNT, size_t TAKES_CONTEXT>
  struct FunctionInfo<T, Ret, void, NAME_COUNT, TAKES_CONTEXT> {
    typedef Ret (T::*Function)(void);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, size_t NAME_COUNT>
  struct FunctionInfo<T, Ret, void, NAME_COUNT, 1> {
    typedef Ret (T::*Function)(CallFunctionErrorContext &);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, size_t NAME_COUNT>
  struct FunctionInfo<T, Ret, void, NAME_COUNT, 2> {
    typedef Ret (T::*Function)(CallFunctionContext &);

    typedef Ret returnType;
    DataRef name[NAME_COUNT];
    Function function;
  };

  /// \private
  template<typename T, typename Ret, typename Arg, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, Arg, sizeof...(Aliases) + 1, 0> makeFunctionInfo(const char (&name)[NAME_SIZE],
    Ret (T::*function)(Arg),
    Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  /// \private
  template<typename T, typename Ret, typename Arg, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, Arg, sizeof...(Aliases) + 1, 1> makeFunctionInfo(
    const char (&name)[NAME_SIZE], Ret (T::*function)(Arg, CallFunctionErrorContext &), Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  /// \private
  template<typename T, typename Ret, typename Arg, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, Arg, sizeof...(Aliases) + 1, 2> makeFunctionInfo(
    const char (&name)[NAME_SIZE], Ret (T::*function)(Arg, CallFunctionContext &), Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  /// \private
  template<typename T, typename Ret, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, void, sizeof...(Aliases) + 1, 0> makeFunctionInfo(const char (&name)[NAME_SIZE],
    Ret (T::*function)(void),
    Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  /// \private
  template<typename T, typename Ret, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, void, sizeof...(Aliases) + 1, 1> makeFunctionInfo(
    const char (&name)[NAME_SIZE], Ret (T::*function)(CallFunctionErrorContext &), Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  /// \private
  template<typename T, typename Ret, size_t NAME_SIZE, typename... Aliases>
  constexpr FunctionInfo<T, Ret, void, sizeof...(Aliases) + 1, 2> makeFunctionInfo(
    const char (&name)[NAME_SIZE], Ret (T::*function)(CallFunctionContext &), Aliases... aliases) {
    return {{DataRef(name), DataRef(aliases)...}, function};
  }

  namespace Internal {
    template<typename T>
    struct HasJsonStructFunctionContainer {
      typedef char yes[1];
      typedef char no[2];

      template<typename C>
      static constexpr yes &test_in_base(typename C::template JsonStructFunctionContainer<C> *);

      template<typename>
      static constexpr no &test_in_base(...);
    };

    template<typename JS_BASE_CONTAINER_STRUCT_T, typename JS_CONTAINER_STRUCT_T>
    struct JsonStructFunctionContainerDummy {
      using TT = decltype(JS_CONTAINER_STRUCT_T::template JsonStructFunctionContainer<
        JS_CONTAINER_STRUCT_T>::js_static_meta_functions_info());
      using ST = decltype(
        JS_CONTAINER_STRUCT_T::template JsonStructFunctionContainer<JS_CONTAINER_STRUCT_T>::js_static_meta_super_info())
      ;

      static const TT &js_static_meta_functions_info() {
        return JS_CONTAINER_STRUCT_T::template JsonStructFunctionContainer<
          JS_CONTAINER_STRUCT_T>::js_static_meta_functions_info();
      }

      static const ST js_static_meta_super_info() {
        return JS_CONTAINER_STRUCT_T::template JsonStructFunctionContainer<
          JS_CONTAINER_STRUCT_T>::js_static_meta_super_info();
      }
    };
  } // namespace Internal

#define JS_FUNCTION(name) JS::makeFunctionInfo(#name, &JS_CONTAINER_STRUCT_T::name)
#define JS_FUNCTION_ALIASES(name, ...) JS::makeFunctionInfo(#name, &JS_CONTAINER_STRUCT_T::name, __VA_ARGS__)
#define JS_FUNCTION_WITH_NAME(member, name) JS::makeFunctionInfo(name, &JS_CONTAINER_STRUCT_T::member)
#define JS_FUNCTION_WITH_NAME_ALIASES(member, name, ...)                                                               \
  JS::makeFunctionInfo(name, &JS_CONTAINER_STRUCT_T::member, __VA_ARGS__)

#define JS_INTERNAL_MAP_APPLY_FUNCTION(m, first) m(#first, &JS_CONTAINER_STRUCT_T::first)

#define JS_INTERNAL_MAP_FUNCTION(m, first, ...)                                                                        \
  JS_INTERNAL_MAP_APPLY_FUNCTION(m, first)                                                                             \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (, JS_INTERNAL_DEFER2(JS_INTERNAL__MAP_FUNCTION)()(m, __VA_ARGS__))(, JS_INTERNAL_MAP_APPLY_FUNCTION(m, __VA_ARGS__))

#define JS_INTERNAL__MAP_FUNCTION() JS_INTERNAL_MAP_FUNCTION

#define JS_INTERNAL_MAKE_FUNCTIONS(...)                                                                                \
  JS_INTERNAL_IF_ELSE(JS_INTERNAL_HAS_MORE_THAN_ONE_ARGS(__VA_ARGS__))                                                 \
  (JS_INTERNAL_EXPAND(JS_INTERNAL_EVAL(JS_INTERNAL_MAP_FUNCTION(JS::makeFunctionInfo, __VA_ARGS__))))(                 \
    JS_INTERNAL_MAP_APPLY_FUNCTION(JS::makeFunctionInfo, __VA_ARGS__))

#define JS_FUNCTION_CONTAINER_INTERNAL_IMPL(super_list, function_list)                                                 \
  template <typename JS_CONTAINER_STRUCT_T>                                                                            \
  struct JsonStructFunctionContainer                                                                                   \
  {                                                                                                                    \
    using TT = decltype(function_list);                                                                                \
    static const TT &js_static_meta_functions_info()                                                                   \
    {                                                                                                                  \
      static auto ret = function_list;                                                                                 \
      return ret;                                                                                                      \
    }                                                                                                                  \
    static const decltype(super_list) js_static_meta_super_info()                                                      \
    {                                                                                                                  \
      return super_list;                                                                                               \
    }                                                                                                                  \
  }

#define JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, super_list, function_list)                                  \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  namespace Internal                                                                                                   \
  {                                                                                                                    \
  template <typename JS_CONTAINER_STRUCT_T>                                                                            \
  struct JsonStructFunctionContainerDummy<Type, JS_CONTAINER_STRUCT_T>                                                 \
  {                                                                                                                    \
    using TT = decltype(function_list);                                                                                \
    static const TT &js_static_meta_functions_info()                                                                   \
    {                                                                                                                  \
      static auto ret = function_list;                                                                                 \
      return ret;                                                                                                      \
    }                                                                                                                  \
    static const decltype(super_list) js_static_meta_super_info()                                                      \
    {                                                                                                                  \
      return super_list;                                                                                               \
    }                                                                                                                  \
  };                                                                                                                   \
  }                                                                                                                    \
  }

#define JS_FUNC_OBJ(...)                                                                                               \
  JS_FUNCTION_CONTAINER_INTERNAL_IMPL(JS::makeTuple(), JS::makeTuple(JS_INTERNAL_MAKE_FUNCTIONS(__VA_ARGS__)))
#define JS_FUNCTION_CONTAINER(...) JS_FUNCTION_CONTAINER_INTERNAL_IMPL(JS::makeTuple(), JS::makeTuple(__VA_ARGS__))
#define JS_FUNC_OBJ_SUPER(super_list, ...)                                                                             \
  JS_FUNCTION_CONTAINER_INTERNAL_IMPL(super_list, JS::makeTuple(JS_INTERNAL_MAKE_FUNCTIONS(__VA_ARGS__)))
#define JS_FUNCTION_CONTAINER_WITH_SUPER(super_list, ...)                                                              \
  JS_FUNCTION_CONTAINER_INTERNAL_IMPL(super_list, JS::makeTuple(__VA_ARGS__))
#define JS_FUNCTION_CONTAINER_WITH_SUPER_WITHOUT_MEMBERS(super_list)                                                   \
  JS_FUNCTION_CONTAINER_INTERNAL_IMPL(super_list, JS::makeTuple())

#define JS_FUNC_OBJ_EXTERNAL(Type, ...)                                                                                \
  JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, JS::makeTuple(),                                                  \
                                               JS::makeTuple(JS_INTERNAL_MAKE_FUNCTIONS(__VA_ARGS__)))
#define JS_FUNCTION_CONTAINER_EXTERNAL(Type, ...)                                                                      \
  JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, JS::makeTuple(), JS::makeTuple(__VA_ARGS__))
#define JS_FUNC_OBJ_EXTERNAL_SUPER(Type, super_list, ...)                                                              \
  JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, super_list, JS::makeTuple(JS_INTERNAL_MAKE_FUNCTIONS(__VA_ARGS__)))
#define JS_FUNCTION_CONTAINER_EXTERNAL_WITH_SUPER(Type, super_list, ...)                                               \
  JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, super_list, JS::makeTuple(__VA_ARGS__))

#define JS_FUNCTION_CONTAINER_EXTERNAL_WITH_SUPER_WITHOUT_MEMBERS(Type, super_list)                                    \
  JS_FUNCTION_CONTAINER_EXTERNAL_INTERNAL_IMPL(Type, super_list, JS::makeTuple())

#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 11
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif

  namespace Internal {
    template<typename T, typename U, typename Ret, typename Arg, size_t NAME_COUNT, size_t TAKES_CONTEXT>
    struct FunctionCaller {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, Ret, Arg, NAME_COUNT, TAKES_CONTEXT> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        Token token;
        TypeHandler<Ret>::from((container.*functionInfo.function)(arg), token, context.return_serializer);
        return Error::NoError;
      }
    };

    template<typename T, typename U, typename Ret, typename Arg, size_t NAME_COUNT>
    struct FunctionCaller<T, U, Ret, Arg, NAME_COUNT, 1> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, Ret, Arg, NAME_COUNT, 1> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        Token token;
        Ret ret = (container.*functionInfo.function)(arg, context.error_context);
        if (context.execution_list.back().error == Error::NoError)
          TypeHandler<Ret>::from(ret, token, context.return_serializer);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, typename Ret, typename Arg, size_t NAME_COUNT>
    struct FunctionCaller<T, U, Ret, Arg, NAME_COUNT, 2> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, Ret, Arg, NAME_COUNT, 2> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        Token token;
        Ret ret = (container.*functionInfo.function)(arg, context);
        if (context.execution_list.back().error == Error::NoError)
          TypeHandler<Ret>::from(ret, token, context.return_serializer);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, typename Arg, size_t NAME_COUNT, size_t TAKES_CONTEXT>
    struct FunctionCaller<T, U, void, Arg, NAME_COUNT, TAKES_CONTEXT> {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, void, Arg, NAME_COUNT, TAKES_CONTEXT> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)(arg);
        return Error::NoError;
      }
    };

    template<typename T, typename U, typename Arg, size_t NAME_COUNT>
    struct FunctionCaller<T, U, void, Arg, NAME_COUNT, 1> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, void, Arg, NAME_COUNT, 1> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)(arg, context.error_context);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, typename Arg, size_t NAME_COUNT>
    struct FunctionCaller<T, U, void, Arg, NAME_COUNT, 2> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, void, Arg, NAME_COUNT, 2> &functionInfo,
                                                  CallFunctionContext &context) {
        typedef typename std::remove_reference<Arg>::type NonRefArg;
        typedef typename std::remove_cv<NonRefArg>::type PureArg;
        PureArg arg;
        context.parse_context.error = TypeHandler<PureArg>::to(arg, context.parse_context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)(arg, context);
        return context.execution_list.back().error;
      }
    };

    static inline void checkValidVoidParameter(CallFunctionContext &context) {
      if (context.parse_context.token.value_type != Type::Null &&
          context.parse_context.token.value_type != Type::ArrayStart &&
          context.parse_context.token.value_type != Type::ObjectStart &&
          context.parse_context.token.value_type != Type::Bool) {
        // what to do
        fprintf(stderr, "Passing data arguments to a void function\n");
      }
      skipArrayOrObject(context.parse_context);
    }

    template<typename T, typename U, typename Ret, size_t NAME_COUNT, size_t TAKES_CONTEXT>
    struct FunctionCaller<T, U, Ret, void, NAME_COUNT, TAKES_CONTEXT> {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, Ret, void, NAME_COUNT, TAKES_CONTEXT> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;
        Token token;
        TypeHandler<Ret>::from((container.*functionInfo.function)(), token, context.return_serializer);
        return Error::NoError;
      }
    };

    template<typename T, typename U, typename Ret, size_t NAME_COUNT>
    struct FunctionCaller<T, U, Ret, void, NAME_COUNT, 1> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, Ret, void, NAME_COUNT, 1> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        Token token;
        Ret ret = (container.*functionInfo.function)(context.error_context);
        if (context.execution_list.back().error == Error::NoError)
          TypeHandler<Ret>::from(ret, token, context.return_serializer);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, typename Ret, size_t NAME_COUNT>
    struct FunctionCaller<T, U, Ret, void, NAME_COUNT, 2> {
      static Error callFunctionAndSerializeReturn(T &container, FunctionInfo<U, Ret, void, NAME_COUNT, 2> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        Token token;
        Ret ret = (container.*functionInfo.function)(context);
        if (context.execution_list.back().error == Error::NoError)
          TypeHandler<Ret>::from(ret, token, context.return_serializer);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, size_t NAME_COUNT, size_t TAKES_CONTEXT>
    struct FunctionCaller<T, U, void, void, NAME_COUNT, TAKES_CONTEXT> {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, void, void, NAME_COUNT, TAKES_CONTEXT> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)();
        return Error::NoError;
      }
    };

    template<typename T, typename U, size_t NAME_COUNT>
    struct FunctionCaller<T, U, void, void, NAME_COUNT, 1> {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, void, void, NAME_COUNT, 1> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)(context.error_context);
        return context.execution_list.back().error;
      }
    };

    template<typename T, typename U, size_t NAME_COUNT>
    struct FunctionCaller<T, U, void, void, NAME_COUNT, 2> {
      static Error callFunctionAndSerializeReturn(T &container,
                                                  FunctionInfo<U, void, void, NAME_COUNT, 2> &functionInfo,
                                                  CallFunctionContext &context) {
        checkValidVoidParameter(context);
        if (context.parse_context.error != Error::NoError)
          return context.parse_context.error;

        (container.*functionInfo.function)(context);
        return context.execution_list.back().error;
      }
    };
  } // namespace Internal

#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 11
#pragma GCC diagnostic pop
#endif

  template<typename T, typename U, typename Ret, typename Arg, size_t NAME_COUNT, size_t TAKES_CONTEXT>
  Error matchAndCallFunction(T &container, CallFunctionContext &context,
                             FunctionInfo<U, Ret, Arg, NAME_COUNT, TAKES_CONTEXT> &functionInfo, bool primary) {
    if (primary && context.parse_context.token.name.size == functionInfo.name[0].size &&
        memcmp(functionInfo.name[0].data, context.parse_context.token.name.data, functionInfo.name[0].size) == 0) {
      return Internal::FunctionCaller<T, U, Ret, Arg, NAME_COUNT, TAKES_CONTEXT>::callFunctionAndSerializeReturn(
        container, functionInfo, context);
    } else if (!primary) {
      for (size_t i = 1; i < NAME_COUNT; i++) {
        if (context.parse_context.token.name.size == functionInfo.name[i].size &&
            memcmp(functionInfo.name[i].data, context.parse_context.token.name.data, functionInfo.name[i].size) == 0) {
          return Internal::FunctionCaller<T, U, Ret, Arg, NAME_COUNT, TAKES_CONTEXT>::callFunctionAndSerializeReturn(
            container, functionInfo, context);
        }
      }
    }
    return Error::MissingFunction;
  }

  namespace Internal {
    template<typename T, size_t INDEX>
    struct FunctionalSuperRecursion {
      static Error callFunction(T &container, CallFunctionContext &context, bool primary);
    };

    template<typename T, size_t SIZE>
    struct StartFunctionalSuperRecursion {
      static Error callFunction(T &container, CallFunctionContext &context, bool primary) {
        return FunctionalSuperRecursion<T, SIZE - 1>::callFunction(container, context, primary);
      }
    };

    template<typename T>
    struct StartFunctionalSuperRecursion<T, 0> {
      static Error callFunction(T &container, CallFunctionContext &context, bool primary) {
        JS_UNUSED(container);
        JS_UNUSED(context);
        JS_UNUSED(primary);
        return Error::MissingFunction;
      }
    };

    template<typename T, typename Functions, size_t INDEX>
    struct FunctionObjectTraverser {
      static Error call(T &container, CallFunctionContext &context, Functions &functions, bool primary) {
        auto function = functions.template get<INDEX>();
        Error error = matchAndCallFunction(container, context, function, primary);
        if (error == Error::NoError)
          return Error::NoError;
        if (error != Error::MissingFunction)
          return context.parse_context.error;
        return FunctionObjectTraverser<T, Functions, INDEX - 1>::call(container, context, functions, primary);
      }
    };

    template<typename T, typename Functions>
    struct FunctionObjectTraverser<T, Functions, 0> {
      static Error call(T &container, CallFunctionContext &context, Functions &functions, bool primary) {
        auto function = functions.template get<0>();
        Error error = matchAndCallFunction(container, context, function, primary);
        if (error == Error::NoError)
          return Error::NoError;
        if (error != Error::MissingFunction)
          return error;
        using SuperMeta = decltype(Internal::template JsonStructFunctionContainerDummy<T,
          T>::js_static_meta_super_info());
        return StartFunctionalSuperRecursion<T, SuperMeta::size>::callFunction(container, context, primary);
      }
    };

    template<typename T, typename Functions>
    struct FunctionObjectTraverser<T, Functions, size_t(-1)> {
      static Error call(T &container, CallFunctionContext &context, Functions &, bool primary) {
        using SuperMeta = decltype(Internal::template JsonStructFunctionContainerDummy<T,
          T>::js_static_meta_super_info());
        return StartFunctionalSuperRecursion<T, SuperMeta::size>::callFunction(container, context, primary);
      }
    };

    static inline void add_error(CallFunctionExecutionState &executionState, ParseContext &context) {
      executionState.error = context.error;
      if (context.error != Error::NoError) {
        if (context.tokenizer.errorContext().custom_message.empty())
          context.tokenizer.updateErrorContext(context.error);
        executionState.error_string.data = context.tokenizer.makeErrorString();
      }
      if (context.missing_members.size())
        std::swap(executionState.missing_members.data, context.missing_members);
      if (context.unassigned_required_members.size())
        std::swap(executionState.unassigned_required_members.data, context.unassigned_required_members);
    }
  } // namespace Internal

  namespace Internal {
    typedef void (CallFunctionContext::*AfterCallFunction)();

    struct RAICallFunctionOnExit {
      RAICallFunctionOnExit(CallFunctionContext &context, AfterCallFunction after)
        : context(context)
          , after(after) {
      }

      ~RAICallFunctionOnExit() {
        (context.*after)();
      }

      CallFunctionContext &context;
      AfterCallFunction after;
    };
  } // namespace Internal

  namespace Internal {
    struct ArrayEndWriter {
      ArrayEndWriter(Serializer &serializer, Token &token)
        : serializer(serializer)
          , token(token) {
      }

      ~ArrayEndWriter() {
        token.value_type = Type::ArrayEnd;
        token.value = DataRef("]");
        serializer.write(token);
      }

      Serializer &serializer;
      Token &token;
    };
  } // namespace Internal

  template<typename T>
  inline Error CallFunctionContext::callFunctions(T &container) {
    beforeCallFunctions();
    Internal::RAICallFunctionOnExit callOnExit(*this, &CallFunctionContext::afterCallFunctions);
    JS::Error error = parse_context.nextToken();
    if (error != JS::Error::NoError)
      return error;
    if (parse_context.token.value_type != JS::Type::ObjectStart) {
      return error_context.setError(Error::ExpectedObjectStart, "Can only call functions on objects with members");
    }
    error = parse_context.nextToken();
    if (error != JS::Error::NoError)
      return error;
    Token token;
    token.value_type = Type::ArrayStart;
    token.value = DataRef("[");
    Internal::ArrayEndWriter endWriter(return_serializer, token);
    return_serializer.write(token);
    auto &functions = Internal::JsonStructFunctionContainerDummy<T, T>::js_static_meta_functions_info();
    using FunctionsType = typename std::remove_reference<decltype(functions)>::type;
    while (parse_context.token.value_type != JS::Type::ObjectEnd) {
      parse_context.tokenizer.pushScope(parse_context.token.value_type);
      execution_list.push_back(
        CallFunctionExecutionState(std::string(parse_context.token.name.data, parse_context.token.name.size)));
      execution_list.back().context.data = user_context;
      error = Internal::FunctionObjectTraverser<T, FunctionsType, FunctionsType::size - 1>::call(container, *this,
        functions, true);
      if (error == Error::MissingFunction)
        error = Internal::FunctionObjectTraverser<T, FunctionsType, FunctionsType::size - 1>::call(container, *this,
          functions, false);
      if (error != Error::NoError) {
        assert(error == parse_context.error || parse_context.error == Error::NoError);
        parse_context.error = error;
      }
      Internal::add_error(execution_list.back(), parse_context);
      parse_context.tokenizer.goToEndOfScope(parse_context.token);
      parse_context.tokenizer.popScope();
      if (error == Error::MissingFunction && allow_missing)
        error = Error::NoError;
      if (stop_execute_on_fail && error != Error::NoError)
        return error;

      error = parse_context.nextToken();
      if (error != JS::Error::NoError)
        return error;
    }

    return Error::NoError;
  }

  struct DefaultCallFunctionContext : public CallFunctionContext {
    DefaultCallFunctionContext(std::string &json_out)
      : CallFunctionContext(p_context, s_context.serializer)
        , s_context(json_out) {
    }

    DefaultCallFunctionContext(const char *data, size_t size, std::string &json_out)
      : CallFunctionContext(p_context, s_context.serializer)
        , p_context(data, size)
        , s_context(json_out) {
    }

    template<size_t SIZE>
    DefaultCallFunctionContext(const char (&data)[SIZE], std::string &json_out)
      : CallFunctionContext(p_context, s_context.serializer)
        , p_context(data)
        , s_context(json_out) {
    }

    ParseContext p_context;
    SerializerContext s_context;

  protected:
    void afterCallFunctions() {
      s_context.flush();
    }
  };

  namespace Internal {
    template<typename T, size_t INDEX>
    Error FunctionalSuperRecursion<T, INDEX>::callFunction(T &container, CallFunctionContext &context, bool primary) {
      using SuperMeta = decltype(Internal::template JsonStructFunctionContainerDummy<T, T>::js_static_meta_super_info())
          ;
      using Super = typename TypeAt<INDEX, SuperMeta>::type::type;
      auto &functions = Internal::template JsonStructFunctionContainerDummy<Super,
        Super>::js_static_meta_functions_info();
      using FunctionsType = typename std::remove_reference<decltype(functions)>::type;
      Error error = FunctionObjectTraverser<Super, FunctionsType, FunctionsType::size - 1>::call(container, context,
        functions, primary);
      if (error != Error::MissingFunction)
        return error;

      return FunctionalSuperRecursion<T, INDEX - 1>::callFunction(container, context, primary);
    }

    template<typename T>
    struct FunctionalSuperRecursion<T, 0> {
      static Error callFunction(T &container, CallFunctionContext &context, bool primary) {
        using SuperMeta = decltype(Internal::template JsonStructFunctionContainerDummy<T,
          T>::js_static_meta_super_info());
        using Super = typename TypeAt<0, SuperMeta>::type::type;
        auto &functions =
            Internal::template JsonStructFunctionContainerDummy<Super, Super>::js_static_meta_functions_info();
        using FunctionsType = typename std::remove_reference<decltype(functions)>::type;
        return FunctionObjectTraverser<Super, FunctionsType, FunctionsType::size - 1>::call(
          container, context, functions,
          primary);
      }
    };
  } // namespace Internal
  namespace Internal {
    enum class ParseEnumStringState {
      FindingNameStart,
      FindingNameEnd,
      FindingSeperator
    };

    template<size_t N>
    void populateEnumNames(std::vector<DataRef> &names, const char (&data)[N]) {
      size_t name_starts_at = 0;
      ParseEnumStringState state = ParseEnumStringState::FindingNameStart;
      for (size_t i = 0; i < N; i++) {
        char c = data[i];
        assert(c != '=');
        switch (state) {
          case ParseEnumStringState::FindingNameStart:
            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
              name_starts_at = i;
              state = ParseEnumStringState::FindingNameEnd;
            }
            break;
          case ParseEnumStringState::FindingNameEnd:
            if (c == '\0' || c == '\t' || c == '\n' || c == '\r' || c == ' ' || c == ',') {
              names.push_back(DataRef(data + name_starts_at, i - name_starts_at));
              state = c == ',' ? ParseEnumStringState::FindingNameStart : ParseEnumStringState::FindingSeperator;
            }
            break;
          case ParseEnumStringState::FindingSeperator:
            if (c == ',')
              state = ParseEnumStringState::FindingNameStart;
            break;
        }
      }
    }
  } // namespace Internal
} // namespace JS

#define JS_ENUM(name, ...)                                                                                             \
  enum class name                                                                                                      \
  {                                                                                                                    \
    __VA_ARGS__                                                                                                        \
  };                                                                                                                   \
  struct js_##name##_string_struct                                                                                     \
  {                                                                                                                    \
    template <size_t N>                                                                                                \
    explicit js_##name##_string_struct(const char (&data)[N])                                                          \
    {                                                                                                                  \
      JS::Internal::populateEnumNames(_strings, data);                                                                 \
    }                                                                                                                  \
    std::vector<JS::DataRef> _strings;                                                                                 \
                                                                                                                       \
    static const std::vector<JS::DataRef> &strings()                                                                   \
    {                                                                                                                  \
      static js_##name##_string_struct ret(#__VA_ARGS__);                                                              \
      return ret._strings;                                                                                             \
    }                                                                                                                  \
  };

#define JS_ENUM_DECLARE_STRING_PARSER(name)                                                                            \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  template <>                                                                                                          \
  struct TypeHandler<name>                                                                                             \
  {                                                                                                                    \
    static inline Error to(name &to_type, ParseContext &context)                                                       \
    {                                                                                                                  \
      return Internal::EnumHandler<name, js_##name##_string_struct>::to(to_type, context);                             \
    }                                                                                                                  \
    static inline void from(const name &from_type, Token &token, Serializer &serializer)                               \
    {                                                                                                                  \
      return Internal::EnumHandler<name, js_##name##_string_struct>::from(from_type, token, serializer);               \
    }                                                                                                                  \
  };                                                                                                                   \
  }

#define JS_ENUM_NAMESPACE_DECLARE_STRING_PARSER(ns, name)                                                              \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  template <>                                                                                                          \
  struct TypeHandler<ns::name>                                                                                         \
  {                                                                                                                    \
    static inline Error to(ns::name &to_type, ParseContext &context)                                                   \
    {                                                                                                                  \
      return Internal::EnumHandler<ns::name, ns::js_##name##_string_struct>::to(to_type, context);                     \
    }                                                                                                                  \
    static inline void from(const ns::name &from_type, Token &token, Serializer &serializer)                           \
    {                                                                                                                  \
      return Internal::EnumHandler<ns::name, ns::js_##name##_string_struct>::from(from_type, token, serializer);       \
    }                                                                                                                  \
  };                                                                                                                   \
  }

#define JS_ENUM_DECLARE_VALUE_PARSER(name)                                                                             \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  template <>                                                                                                          \
  struct TypeHandler<name>                                                                                             \
  {                                                                                                                    \
    typedef std::underlying_type<name>::type utype;                                                                    \
    static inline Error to(name &to_type, ParseContext &context)                                                       \
    {                                                                                                                  \
      utype to_value;                                                                                                  \
      JS::Error result = TypeHandler<utype>::to(to_value, context);                                                    \
      if (result == JS::Error::NoError)                                                                                \
        to_type = static_cast<name>(to_value);                                                                         \
      return result;                                                                                                   \
    }                                                                                                                  \
    static inline void from(const name &from_type, Token &token, Serializer &serializer)                               \
    {                                                                                                                  \
        const utype from_value = static_cast<utype>(from_type);                                                        \
        TypeHandler<utype>::from(from_value, token, serializer);                                                       \
    }                                                                                                                  \
  };                                                                                                                   \
  }

#define JS_ENUM_NAMESPACE_DECLARE_VALUE_PARSER(ns, name)                                                               \
  namespace JS                                                                                                         \
  {                                                                                                                    \
  template <>                                                                                                          \
  struct TypeHandler<ns::name>                                                                                         \
  {                                                                                                                    \
    typedef std::underlying_type<ns::name>::type utype;                                                                \
    static inline Error to(ns::name &to_type, ParseContext &context)                                                   \
    {                                                                                                                  \
      utype to_value;                                                                                                  \
      JS::Error result = TypeHandler<utype>::to(to_value, context);                                                    \
      if (result == JS::Error::NoError)                                                                                \
        to_type = static_cast<ns::name>(to_value);                                                                     \
      return result;                                                                                                   \
    }                                                                                                                  \
    static inline void from(const ns::name &from_type, Token &token, Serializer &serializer)                           \
    {                                                                                                                  \
        const utype from_value = static_cast<utype>(from_type);                                                        \
        TypeHandler<utype>::from(from_value, token, serializer);                                                       \
    }                                                                                                                  \
  };                                                                                                                   \
  }

namespace
JS {
  template<typename T, typename Enable>
  inline Error TypeHandler<T, Enable>::to(T &to_type, ParseContext &context) {
    if (context.token.value_type != JS::Type::ObjectStart)
      return Error::ExpectedObjectStart;
    Error error = context.tokenizer.nextToken(context.token);
    if (error != JS::Error::NoError)
      return error;
    auto members = Internal::JsonStructBaseDummy<T, T>::js_static_meta_data_info();
    using MembersType = decltype(members);
    bool assigned_members[Internal::memberCount<T, 0>()];
    memset(assigned_members, 0, sizeof(assigned_members));
    while (context.token.value_type != JS::Type::ObjectEnd) {
      DataRef token_name = context.token.name;
      error = Internal::MemberChecker<T, MembersType, 0, MembersType::size - 1>::unpackMembers(
        to_type, members, context,
        true, assigned_members);
      if (error == Error::MissingPropertyMember)
        error = Internal::MemberChecker<T, MembersType, 0, MembersType::size - 1>::unpackMembers(
          to_type, members, context, false, assigned_members);
      if (error == Error::MissingPropertyMember) {
        if (context.track_member_assignement_state)
          context.missing_members.emplace_back(token_name.data, token_name.data + token_name.size);
        if (context.allow_missing_members) {
          Internal::skipArrayOrObject(context);
          if (context.error != Error::NoError)
            return context.error;
        } else {
          return error;
        }
      } else if (error != Error::NoError) {
        return error;
      }
      context.nextToken();
      if (context.error != Error::NoError)
        return context.error;
    }
    std::vector<std::string> unassigned_required_members;
    error = Internal::MemberChecker<T, MembersType, 0, MembersType::size - 1>::verifyMembers(
      members, assigned_members, context.track_member_assignement_state, unassigned_required_members, "");
    if (error == Error::UnassignedRequiredMember) {
      if (context.track_member_assignement_state)
        context.unassigned_required_members.insert(context.unassigned_required_members.end(),
                                                   unassigned_required_members.begin(),
                                                   unassigned_required_members.end());
      if (context.allow_unasigned_required_members)
        error = Error::NoError;
    }
    return error;
  }

  template<typename T, typename Enable>
  void TypeHandler<T, Enable>::from(const T &from_type, Token &token, Serializer &serializer) {
    static const char objectStart[] = "{";
    static const char objectEnd[] = "}";
    token.value_type = Type::ObjectStart;
    token.value = DataRef(objectStart);
    serializer.write(token);
    auto members = Internal::JsonStructBaseDummy<T, T>::js_static_meta_data_info();
    using MembersType = decltype(members);
    Internal::MemberChecker<T, MembersType, 0, MembersType::size - 1>::serializeMembers(from_type, members, token,
      serializer, "");
    token.name.size = 0;
    token.name.data = "";
    token.name_type = Type::String;
    token.value_type = Type::ObjectEnd;
    token.value = DataRef(objectEnd);
    serializer.write(token);
  }

  namespace Internal {
    template<typename T, typename F>
    struct EnumHandler {
      static inline Error to(T &to_type, ParseContext &context) {
        if (context.token.value_type == Type::String) {
          auto &strings = F::strings();
          for (size_t i = 0; i < strings.size(); i++) {
            const DataRef &ref = strings[i];
            if (ref.size == context.token.value.size) {
              if (memcmp(ref.data, context.token.value.data, ref.size) == 0) {
                to_type = static_cast<T>(i);
                return Error::NoError;
              }
            }
          }
        } else if (context.token.value_type == Type::Number) {
          using enum_int_t = typename std::underlying_type<T>::type;
          enum_int_t tmp;
          auto err = TypeHandler<enum_int_t>::to(tmp, context);
          if (err != Error::NoError)
            return err;
          to_type = static_cast<T>(tmp);
          return Error::NoError;
        }

        return Error::IllegalDataValue;
      }

      static inline void from(const T &from_type, Token &token, Serializer &serializer) {
        size_t i = static_cast<size_t>(from_type);
        token.value = F::strings()[i];
        token.value_type = Type::String;
        serializer.write(token);
      }
    };
  } // namespace Internal

  namespace Internal {
    static void push_back_escape(char current_char, std::string &to_type) {
      static const char escaped_table[] = {'b', 'f', 'n', 'r', 't', '\"', '\\', '/'};
      static const char replace_table[] = {'\b', '\f', '\n', '\r', '\t', '\"', '\\', '/'};
      static_assert(sizeof(escaped_table) == sizeof(replace_table), "Static tables have to be the same.");
      const char *it = static_cast<const char *>(memchr(escaped_table, current_char, sizeof(escaped_table)));
      if (it) {
        to_type.push_back(replace_table[(it - escaped_table)]);
      } else {
        to_type.push_back('\\');
        to_type.push_back(current_char);
      }
    }

    static void handle_json_escapes_in(const DataRef &ref, std::string &to_type) {
      to_type.reserve(ref.size);
      const char *it = ref.data;
      size_t size = ref.size;
      while (size) {
        const char *next_it = static_cast<const char *>(memchr(it, '\\', size));
        if (!next_it) {
          to_type.insert(to_type.end(), it, it + size);
          break;
        }
        to_type.insert(to_type.end(), it, next_it);
        size -= next_it - it;
        if (!size) {
          break;
        }
        size -= 2;
        const char current_char = *(next_it + 1);
        // we assume utf-8 encoding when this notation is used and parsing into std::string
        if (current_char == 'u') // hexadecimal escaped unicode character
        {
          // first convert hex ascii digits to values between 0 and 15, then create
          // UTF-8 bit patterns according to https://en.wikipedia.org/wiki/UTF-8
          bool ok = (size >= 4);
          unsigned char hex[4];
          for (int k = 0; ok && k < 4; k++) {
            const char d = *(next_it + k + 2);
            if (d >= '0' && d <= '9')
              hex[k] = (d - '0');
            else if (d >= 'A' && d <= 'F')
              hex[k] = (d - 'A') + 10;
            else if (d >= 'a' && d <= 'f')
              hex[k] = (d - 'a') + 10;
            else
              ok = false; // stop parsing and revert to fallback
          }
          if (ok) {
            if (hex[0] || hex[1] & 0x08) {
              // code points: 0x0800 .. 0xffff
              to_type.push_back(0xd0 | hex[0]);
              to_type.push_back(0x80 | (hex[1] << 2) | ((hex[2] & 0x0c) >> 2));
              to_type.push_back(0x80 | ((hex[2] & 0x03) << 4) | hex[3]);
            } else if (hex[1] || hex[2] & 0x08) {
              // code points: 0x0080 .. 0x07ff
              to_type.push_back(0xc0 | (hex[1] << 2) | ((hex[2] & 0x0c) >> 2));
              to_type.push_back(0x80 | ((hex[2] & 0x03) << 4) | hex[3]);
            } else {
              // code points: 0x0000 .. 0x007f
              to_type.push_back((hex[2] << 4) | hex[3]);
            }
            it = next_it + 6; // advance past hex digits
            size -= 4;
          } else {
            // fallback is to simply push characters as is
            to_type.push_back('\\');
            to_type.push_back(current_char);
            it = next_it + 2;
          }
        } else {
          push_back_escape(current_char, to_type);
          it = next_it + 2;
        }
        if (!size)
          break;
      }
    }

    static DataRef handle_json_escapes_out(const std::string &data, std::string &buffer) {
      int start_index = 0;
      for (size_t i = 0; i < data.size(); i++) {
        const char cur = data[i];
        if (static_cast<uint8_t>(cur) <= uint8_t('\r') || cur == '\"' || cur == '\\') {
          if (buffer.empty()) {
            buffer.reserve(data.size() + 10);
          }
          size_t diff = i - start_index;
          if (diff > 0) {
            buffer.insert(buffer.end(), data.data() + start_index, data.data() + start_index + diff);
          }
          start_index = int(i) + 1;

          switch (cur) {
            case '\b':
              buffer += std::string("\\b");
              break;
            case '\t':
              buffer += std::string("\\t");
              break;
            case '\n':
              buffer += std::string("\\n");
              break;
            case '\f':
              buffer += std::string("\\f");
              break;
            case '\r':
              buffer += std::string("\\r");
              break;
            case '\"':
              buffer += std::string("\\\"");
              break;
            case '\\':
              buffer += std::string("\\\\");
              break;
            default:
              buffer.push_back(cur);
              break;
          }
        }
      }
      if (buffer.size()) {
        size_t diff = data.size() - start_index;
        if (diff > 0) {
          buffer.insert(buffer.end(), data.data() + start_index, data.data() + start_index + diff);
        }
        return DataRef(buffer.data(), buffer.size());
      }
      return DataRef(data.data(), data.size());
    }
  } // namespace Internal
  /// \private
  template<>
  struct TypeHandler<std::string> {
    static inline Error to(std::string &to_type, ParseContext &context) {
      to_type.clear();
      Internal::handle_json_escapes_in(context.token.value, to_type);
      return Error::NoError;
    }

    static inline void from(const std::string &str, Token &token, Serializer &serializer) {
      std::string buffer;
      DataRef ref = Internal::handle_json_escapes_out(str, buffer);
      token.value_type = Type::String;
      token.value.data = ref.data;
      token.value.size = ref.size;
      serializer.write(token);
    }
  };

  namespace Internal {
    // This code is taken from https://github.com/jorgen/float_tools
    namespace ft {
      template<typename T>
      struct float_base10 {
        uint8_t negative;
        uint8_t inf;
        uint8_t nan;
        uint8_t significand_digit_count;
        int exp;
        T significand;
      };

      template<typename T>
      struct parsed_string : float_base10<T> {
        const char *endptr;
      };

      enum class parse_string_error {
        ok,
        invalid_format,
        multiple_commas,
        empty_string,
        illegal_exponent_value
      };

      constexpr static inline uint64_t high(uint64_t x) {
        return x >> 32;
      }

      constexpr static inline uint64_t low(uint64_t x) {
        return x & ~uint32_t(0);
      }

      template<int shift = 1>
      inline void left_shift(uint64_t (&a)[2]) {
        static_assert(shift < sizeof(*a) * 8,
                      "This functions does only support shifting by sizes smaller than sizeof(*a) * 8");
        a[1] = a[1] << shift | (a[0] >> (int(sizeof(uint64_t) * 8) - shift));
        a[0] = a[0] << shift;
      }

      template<int shift = 1>
      inline void left_shift(uint64_t &a) {
        static_assert(shift < sizeof(a) * 8,
                      "This functions does only support shifting by sizes smaller than sizeof(*a) * 8");
        a = a << shift;
      }

      inline void left_shift(uint64_t (&a)[2], int shift) {
        if (shift > int(sizeof(*a)) * 8) {
          auto shift_0 = (int(sizeof(uint64_t) * 8) - shift);
          if (shift_0 > 0)
            a[1] = a[0] >> shift_0;
          else
            a[1] = a[0] << -shift_0;

          a[0] = 0;
        } else {
          a[1] = a[1] << shift | (a[0] >> (int(sizeof(uint64_t) * 8) - shift));
          a[0] = a[0] << shift;
        }
      }

      inline void left_shift(uint64_t &a, int shift) {
        a = a << shift;
      }

      inline void right_shift(uint64_t (&a)[2]) {
        a[0] = a[0] >> 1 | (a[1] << ((sizeof(uint64_t) * 8) - 1));
        a[1] = a[1] >> 1;
      }

      inline void right_shift(uint64_t &a) {
        a = a >> 1;
      }

      inline uint64_t mask32(uint64_t a) {
        return a & ((uint64_t(1) << 32) - 1);
      }

      inline void add(const uint64_t (&a)[2], uint64_t (&b)[2]) {
        uint64_t tmplow[2];
        uint64_t tmphigh[2];
        tmplow[0] = low(a[0]) + low(b[0]);
        tmplow[1] = low(a[1]) + low(b[1]);
        tmphigh[0] = high(a[0]) + high(b[0]);
        tmphigh[1] = high(a[1]) + high(b[1]);

        tmphigh[0] += tmplow[0] >> 32;
        tmplow[1] += tmphigh[0] >> 32;
        tmphigh[1] += tmplow[1] >> 32;

        b[0] = mask32(tmplow[0]) | (tmphigh[0] << 32);
        b[1] = mask32(tmplow[1]) | (tmphigh[1] << 32);
      }

      inline void add(const uint64_t &a, uint64_t &b) {
        b += a;
      }

      inline void divide_by_10(uint64_t (&a)[2]) {
        uint64_t remainder = a[1] % 10;
        a[1] /= 10;
        uint64_t high_pluss_reminder = high(a[0]) + (remainder << 32);
        uint64_t high_d = high_pluss_reminder / 10;
        uint64_t high_r = high_pluss_reminder % 10;
        uint64_t low_d = (low(a[0]) + (high_r << 32)) / 10;
        a[0] = high_d << 32 | low_d;
      }

      inline void divide_by_10(uint64_t &a) {
        a /= 10;
      }

      template<typename T>
      struct float_info {
      };

      static inline int bit_scan_reverse(uint64_t a) {
        assert(a);
#ifdef _MSC_VER
        unsigned long index;
#ifdef _WIN64
        _BitScanReverse64(&index, a);
#else
  if (_BitScanReverse(&index, a >> 32))
    index += 32;
  else
    _BitScanReverse(&index, a & (~uint32_t(0)));
#endif
        return int(index);
#else
  static_assert(sizeof(unsigned long long) == sizeof(uint64_t), "Wrong size for builtin_clzll");
  return 63 - __builtin_clzll(a);
#endif
      }

      template<>
      struct float_info<double> {
        static inline constexpr int mentissa_width() noexcept {
          return 52;
        }

        static inline constexpr int exponent_width() noexcept {
          return 11;
        }

        static inline constexpr int bias() noexcept {
          return (1 << (exponent_width() - 1)) - 1;
        }

        static inline constexpr int max_base10_exponent() noexcept {
          return 308;
        }

        static inline constexpr int min_base10_exponent() noexcept {
          return -324;
        }

        static inline constexpr int max_double_5_pow_q() noexcept {
          return 23;
        } // floor(log_5(1 << (mentissawidth + 2)))
        static inline constexpr int max_double_2_pow_q() noexcept {
          return 54;
        } // floor(log_2(1 << (mentissawidth + 2)))

        using str_to_float_conversion_type = uint64_t[2];
        using uint_alias = uint64_t;

        static inline constexpr int str_to_float_binary_exponent_init() noexcept {
          return 64 + 60;
        }

        static inline constexpr uint64_t str_to_float_mask() noexcept {
          return ~((uint64_t(1) << 60) - 1);
        }

        static inline constexpr uint64_t str_to_float_top_bit_in_mask() noexcept {
          return uint64_t(1) << 63;
        }

        static inline constexpr int str_to_float_expanded_length() noexcept {
          return 19;
        }

        static inline constexpr bool conversion_type_has_mask(const str_to_float_conversion_type &a) noexcept {
          return a[1] & str_to_float_mask();
        }

        static inline constexpr bool
        conversion_type_has_top_bit_in_mask(const str_to_float_conversion_type &a) noexcept {
          return a[1] & str_to_float_top_bit_in_mask();
        }

        static inline constexpr bool conversion_type_is_null(const str_to_float_conversion_type &a) noexcept {
          return !a[0] && !a[1];
        }

        static inline int shift_left_msb_to_index(str_to_float_conversion_type &a, int index) {
          if (a[1]) {
            int msb = bit_scan_reverse(a[1]);
            int shift_count = index - (msb + 64);
            if (shift_count < 0)
              return 0;
            left_shift(a, shift_count);
            return shift_count;
          } else if (a[0]) {
            int msb = bit_scan_reverse(a[0]);
            int shift_count = index - msb;
            if (shift_count < 0)
              return 0;
            left_shift(a, shift_count);
            return shift_count;
          }
          return 0;
        }

        static inline void copy_denormal_to_type(const str_to_float_conversion_type &a, int binary_exponent,
                                                 bool negative,
                                                 double &to_digit) {
          uint64_t q = a[1];
          int expo_shift = -binary_exponent + 9;
          if (expo_shift) {
            q += uint64_t(1) << (expo_shift - 1);
            q >>= expo_shift;
          }
          if (negative)
            q |= uint64_t(1) << 63;
          memcpy(&to_digit, &q, sizeof(q));
        }

        static inline void copy_normal_to_type(const str_to_float_conversion_type &a, int binary_exponent,
                                               bool negative,
                                               double &to_digit) {
          uint64_t q = a[1] & ~str_to_float_mask();
          uint64_t to_round_off = (q & ((uint64_t(1) << 8) - 1));
          bool bigger = to_round_off > (uint64_t(1) << (8 - 1)) || (to_round_off == (uint64_t(1) << (8 - 1)) && a[0]);
          bool tie_odd = (!(q & ((uint64_t(1) << 7) - 1))) && (q & (uint64_t(1) << 8)) && !a[0];
          if (bigger || tie_odd) {
            q += uint64_t(1) << (8 - 1);
          }
          q >>= 8;
          q += uint64_t(binary_exponent) << mentissa_width();
          if (negative)
            q |= uint64_t(1) << 63;
          memcpy(&to_digit, &q, sizeof(q));
        }
      };

      template<typename T>
      inline void get_parts(T f, bool &negative, int &exp, uint64_t &mentissa) {
        uint64_t bits = 0;
        static_assert(sizeof(bits) >= sizeof(f), "Incompatible size");
        memcpy(&bits, &f, sizeof(f));
        exp = int((bits >> float_info<T>::mentissa_width()) & (((uint64_t(1) << float_info<T>::exponent_width()) - 1)));
        mentissa = bits & ((uint64_t(1) << float_info<T>::mentissa_width()) - 1);
        negative = bits >> ((sizeof(f) * 8) - 1);
      }

      template<typename T>
      inline void assign_significand_to_float_conversion_type(const float_base10<T> &significand, uint64_t (&a)[2]) {
        a[0] = significand.significand;
        a[1] = 0;
      }

      inline void copy_conversion_type(const uint64_t (&a)[2], uint64_t (&b)[2]) {
        memcpy(&b, &a, sizeof(b));
      }

      template<>
      struct float_info<float> {
        static inline constexpr int mentissa_width() noexcept {
          return 23;
        }

        static inline constexpr int exponent_width() noexcept {
          return 8;
        }

        static inline constexpr int bias() noexcept {
          return (1 << (exponent_width() - 1)) - 1;
        }

        static inline constexpr int max_base10_exponent() noexcept {
          return 38;
        }

        static inline constexpr int min_base10_exponent() noexcept {
          return -45;
        }

        static inline constexpr int max_double_5_pow_q() noexcept {
          return 10;
        } // floor(log_5(1 << (mentissawidth + 2)))
        static inline constexpr int max_double_2_pow_q() noexcept {
          return 25;
        } // floor(log_2(1 << (mentissawidth + 2)))

        using str_to_float_conversion_type = uint64_t;
        using uint_alias = uint32_t;

        static inline constexpr int str_to_float_binary_exponent_init() noexcept {
          return 60;
        }

        static inline constexpr uint64_t str_to_float_mask() noexcept {
          return ~((uint64_t(1) << 60) - 1);
        }

        static inline constexpr uint64_t str_to_float_top_bit_in_mask() noexcept {
          return uint64_t(1) << 63;
        }

        static inline constexpr int str_to_float_expanded_length() noexcept {
          return 10;
        }

        static inline constexpr bool conversion_type_has_mask(const str_to_float_conversion_type &a) noexcept {
          return a & str_to_float_mask();
        }

        static inline constexpr bool
        conversion_type_has_top_bit_in_mask(const str_to_float_conversion_type &a) noexcept {
          return a & str_to_float_top_bit_in_mask();
        }

        static inline constexpr bool conversion_type_is_null(const str_to_float_conversion_type &a) noexcept {
          return !a;
        }

        static inline int shift_left_msb_to_index(str_to_float_conversion_type &a, int index) {
          if (a) {
            int msb = bit_scan_reverse(a);
            int shift_count = index - msb;
            if (shift_count < 0)
              return 0;
            left_shift(a, shift_count);
            return shift_count;
          }
          return 0;
        }

        static inline void copy_denormal_to_type(const str_to_float_conversion_type &a, int binary_exponent,
                                                 bool negative,
                                                 float &to_digit) {
          uint64_t q = a;
          int expo_shift = -binary_exponent + 38;
          if (expo_shift) {
            q += uint64_t(1) << (expo_shift - 1);
            q >>= expo_shift;
          }
          if (negative)
            q |= uint64_t(1) << 31;
          uint32_t to_copy = uint32_t(q);
          memcpy(&to_digit, &to_copy, sizeof(to_copy));
        }

        static inline void copy_normal_to_type(const str_to_float_conversion_type &a, int binary_exponent,
                                               bool negative,
                                               float &to_digit) {
          uint64_t q = a & ~str_to_float_mask();
          bool bigger = (q & ((uint64_t(1) << 37) - 1)) > (uint64_t(1) << (37 - 1));
          bool tie_odd = (!(q & ((uint64_t(1) << 36) - 1))) && (q & (uint64_t(1) << 37));
          if (bigger || tie_odd) {
            q += (uint64_t(1) << (37 - 1));
          }
          q >>= 37;
          q += uint64_t(binary_exponent) << mentissa_width();
          if (negative)
            q |= uint64_t(1) << 31;
          uint32_t to_copy = uint32_t(q);
          memcpy(&to_digit, &to_copy, sizeof(to_digit));
        }
      };

      template<typename T>
      inline T make_zero(bool negative) {
        using uint_ft = typename float_info<T>::uint_alias;
        uint_ft tmp = 0;
        tmp = uint_ft(negative) << ((sizeof(T) * 8) - 1);
        T ret;
        memcpy(&ret, &tmp, sizeof(ret));
        return ret;
      }

      template<typename T>
      inline T make_inf(bool negative) {
        using uint_ft = typename float_info<T>::uint_alias;
        uint_ft tmp = (uint_ft(1) << float_info<T>::exponent_width()) - 1;
        tmp <<= float_info<T>::mentissa_width();
        tmp += uint_ft(negative) << ((sizeof(T) * 8) - 1);
        T ret;
        memcpy(&ret, &tmp, sizeof(ret));
        return ret;
      }

      template<typename T>
      inline T make_nan(bool positive, uint64_t pos = 1) {
        if (pos == 0)
          pos++;
        using uint_ft = typename float_info<T>::uint_alias;
        uint_ft tmp = (uint_ft(1) << float_info<T>::exponent_width()) - 1;
        tmp <<= float_info<T>::mentissa_width();
        tmp |= pos;
        tmp |= uint_ft(!positive) << ((sizeof(T) * 8) - 1);
        T ret;
        memcpy(&ret, &tmp, sizeof(ret));
        return ret;
      }

      template<typename T>
      inline bool is_nan(T t) {
        bool negative;
        int exp;
        uint64_t mentissa;
        get_parts(t, negative, exp, mentissa);
        return exp == ((int(1) << float_info<T>::exponent_width()) - 1) && mentissa > 0;
      }

      template<typename T>
      inline bool is_inf(T t) {
        bool negative;
        int exp;
        uint64_t mentissa;
        get_parts(t, negative, exp, mentissa);
        return exp == ((int(1) << float_info<T>::exponent_width()) - 1) && mentissa == 0;
      }

      template<typename T>
      const T &max(const T &a, const T &b) {
        return (a < b) ? b : a;
      }

      template<typename T>
      const T &min(const T &a, const T &b) {
        return (b < a) ? b : a;
      }

      template<typename I, typename P>
      I find_if(I first, I last, P p) {
        for (; first != last; ++first) {
          if (p(*first)) {
            return first;
          }
        }
        return last;
      }

      template<typename T>
      inline void assign_significand_to_float_conversion_type(const float_base10<T> &significand, uint64_t &a) {
        a = significand.significand;
      }

      inline void copy_conversion_type(const uint64_t &a, uint64_t &b) {
        b = a;
      }

      template<typename T, int COUNT, T SUM>
      struct Pow10 {
        static inline T get() noexcept {
          return Pow10<T, COUNT - 1, SUM * T(10)>::get();
        }
      };

      template<typename T, T SUM>
      struct Pow10<T, 1, SUM> {
        static inline T get() noexcept {
          return SUM;
        }
      };

      template<typename T, T SUM>
      struct Pow10<T, 0, SUM> {
        static inline T get() noexcept {
          return 1;
        }
      };

      template<typename T, T VALUE, int SUM, T ABORT_VALUE, bool CONTINUE>
      struct StaticLog10 {
        constexpr static int get() noexcept {
          return StaticLog10<T, VALUE / 10, SUM + 1, ABORT_VALUE, VALUE / 10 != ABORT_VALUE>::get();
        }
      };

      template<typename T, T VALUE, T ABORT_VALUE, int SUM>
      struct StaticLog10<T, VALUE, SUM, ABORT_VALUE, false> {
        constexpr static int get() noexcept {
          return SUM;
        }
      };

      template<typename T, int WIDTH, int CURRENT>
      struct CharsInDigit {
        static int lower_bounds(T t) noexcept {
          if (Pow10<T, CURRENT + WIDTH / 2, 1>::get() - 1 < t) {
            return CharsInDigit<T, WIDTH - (WIDTH / 2 + 1), CURRENT + WIDTH / 2 + 1>::lower_bounds(t);
          }
          return CharsInDigit<T, WIDTH / 2, CURRENT>::lower_bounds(t);
        }
      };

      template<typename T, int CURRENT>
      struct CharsInDigit<T, 0, CURRENT> {
        static int lower_bounds(T) noexcept {
          return CURRENT;
        }
      };

      template<typename T, int CURRENT>
      struct CharsInDigit<T, -1, CURRENT> {
        static int lower_bounds(T) noexcept {
          return CURRENT;
        }
      };

      template<typename T>
      T iabs(typename std::enable_if<std::is_unsigned<T>::value, T>::type a) {
        return a;
      }

      template<typename T>
      T iabs(typename std::enable_if<std::is_signed<T>::value, T>::type a) {
        // this
        if (a > 0)
          return a;
        if (a == std::numeric_limits<T>::min())
          a++;
        return -a;
      }

      template<typename T>
      int count_chars(T t) noexcept {
        if (iabs<T>(t) < T(10))
          return 1;
        constexpr int maxChars = StaticLog10<T, std::numeric_limits<T>::max(), 0, 0, true>::get() + 1;
        return CharsInDigit<T, maxChars, 0>::lower_bounds(iabs<T>(t)) - 1;
      }

      namespace ryu {
        template<typename T>
        struct cache_values {
        };

        template<>
        struct cache_values<double> {
          constexpr static const int b0 = 124;
          constexpr static const int b1 = 124;

          static const uint64_t *less_than(int index) {
            static const uint64_t data[326][2] = {
              {
                /*  0*/ UINT64_C(0), UINT64_C(1152921504606846976)
              },
              {
                /*  1*/ UINT64_C(0), UINT64_C(720575940379279360)
              },
              {
                /*  2*/ UINT64_C(0), UINT64_C(900719925474099200)
              },
              {
                /*  3*/ UINT64_C(0), UINT64_C(1125899906842624000)
              },
              {
                /*  4*/ UINT64_C(0), UINT64_C(703687441776640000)
              },
              {
                /*  5*/ UINT64_C(0), UINT64_C(879609302220800000)
              },
              {
                /*  6*/ UINT64_C(0), UINT64_C(1099511627776000000)
              },
              {
                /*  7*/ UINT64_C(0), UINT64_C(687194767360000000)
              },
              {
                /*  8*/ UINT64_C(0), UINT64_C(858993459200000000)
              },
              {
                /*  9*/ UINT64_C(0), UINT64_C(1073741824000000000)
              },
              {
                /* 10*/ UINT64_C(0), UINT64_C(671088640000000000)
              },
              {
                /* 11*/ UINT64_C(0), UINT64_C(838860800000000000)
              },
              {
                /* 12*/ UINT64_C(0), UINT64_C(1048576000000000000)
              },
              {
                /* 13*/ UINT64_C(0), UINT64_C(655360000000000000)
              },
              {
                /* 14*/ UINT64_C(0), UINT64_C(819200000000000000)
              },
              {
                /* 15*/ UINT64_C(0), UINT64_C(1024000000000000000)
              },
              {
                /* 16*/ UINT64_C(0), UINT64_C(640000000000000000)
              },
              {
                /* 17*/ UINT64_C(0), UINT64_C(800000000000000000)
              },
              {
                /* 18*/ UINT64_C(0), UINT64_C(1000000000000000000)
              },
              {
                /* 19*/ UINT64_C(0), UINT64_C(625000000000000000)
              },
              {
                /* 20*/ UINT64_C(0), UINT64_C(781250000000000000)
              },
              {
                /* 21*/ UINT64_C(0), UINT64_C(976562500000000000)
              },
              {
                /* 22*/ UINT64_C(0), UINT64_C(610351562500000000)
              },
              {
                /* 23*/ UINT64_C(0), UINT64_C(762939453125000000)
              },
              {
                /* 24*/ UINT64_C(0), UINT64_C(953674316406250000)
              },
              {
                /* 25*/ UINT64_C(0), UINT64_C(596046447753906250)
              },
              {
                /* 26*/ UINT64_C(9223372036854775808), UINT64_C(745058059692382812)
              },
              {
                /* 27*/ UINT64_C(11529215046068469760), UINT64_C(931322574615478515)
              },
              {
                /* 28*/ UINT64_C(4899916394579099648), UINT64_C(582076609134674072)
              },
              {
                /* 29*/ UINT64_C(6124895493223874560), UINT64_C(727595761418342590)
              },
              {
                /* 30*/ UINT64_C(16879491403384619008), UINT64_C(909494701772928237)
              },
              {
                /* 31*/ UINT64_C(7264306198948610048), UINT64_C(1136868377216160297)
              },
              {
                /* 32*/ UINT64_C(16069406420411351040), UINT64_C(710542735760100185)
              },
              {
                /* 33*/ UINT64_C(6251699970232025088), UINT64_C(888178419700125232)
              },
              {
                /* 34*/ UINT64_C(7814624962790031360), UINT64_C(1110223024625156540)
              },
              {
                /* 35*/ UINT64_C(14107512638598545408), UINT64_C(693889390390722837)
              },
              {
                /* 36*/ UINT64_C(3799332742966018048), UINT64_C(867361737988403547)
              },
              {
                /* 37*/ UINT64_C(137479910280134656), UINT64_C(1084202172485504434)
              },
              {
                /* 38*/ UINT64_C(4697610962352472064), UINT64_C(677626357803440271)
              },
              {
                /* 39*/ UINT64_C(1260327684513202176), UINT64_C(847032947254300339)
              },
              {
                /* 40*/ UINT64_C(15410467660923666432), UINT64_C(1058791184067875423)
              },
              {
                /* 41*/ UINT64_C(16549071315718373376), UINT64_C(661744490042422139)
              },
              {
                /* 42*/ UINT64_C(16074653126220578816), UINT64_C(827180612553027674)
              },
              {
                /* 43*/ UINT64_C(10869944370920947712), UINT64_C(1033975765691284593)
              },
              {
                /* 44*/ UINT64_C(18322930277894062080), UINT64_C(646234853557052870)
              },
              {
                /* 45*/ UINT64_C(13680290810512801792), UINT64_C(807793566946316088)
              },
              {
                /* 46*/ UINT64_C(17100363513141002240), UINT64_C(1009741958682895110)
              },
              {
                /* 47*/ UINT64_C(6076041177285738496), UINT64_C(631088724176809444)
              },
              {
                /* 48*/ UINT64_C(7595051471607173120), UINT64_C(788860905221011805)
              },
              {
                /* 49*/ UINT64_C(14105500357936354304), UINT64_C(986076131526264756)
              },
              {
                /* 50*/ UINT64_C(18039309760564997248), UINT64_C(616297582203915472)
              },
              {
                /* 51*/ UINT64_C(4102393126996694944), UINT64_C(770371977754894341)
              },
              {
                /* 52*/ UINT64_C(9739677427173256584), UINT64_C(962964972193617926)
              },
              {
                /* 53*/ UINT64_C(1475612373555897461), UINT64_C(601853107621011204)
              },
              {
                /* 54*/ UINT64_C(1844515466944871826), UINT64_C(752316384526264005)
              },
              {
                /* 55*/ UINT64_C(6917330352108477686), UINT64_C(940395480657830006)
              },
              {
                /* 56*/ UINT64_C(18158389525349962266), UINT64_C(587747175411143753)
              },
              {
                /* 57*/ UINT64_C(8862928851405289120), UINT64_C(734683969263929692)
              },
              {
                /* 58*/ UINT64_C(11078661064256611401), UINT64_C(918354961579912115)
              },
              {
                /* 59*/ UINT64_C(9236640311893376347), UINT64_C(1147943701974890144)
              },
              {
                /* 60*/ UINT64_C(5772900194933360217), UINT64_C(717464813734306340)
              },
              {
                /* 61*/ UINT64_C(7216125243666700271), UINT64_C(896831017167882925)
              },
              {
                /* 62*/ UINT64_C(13631842573010763243), UINT64_C(1121038771459853656)
              },
              {
                /* 63*/ UINT64_C(8519901608131727026), UINT64_C(700649232162408535)
              },
              {
                /* 64*/ UINT64_C(6038190991737270879), UINT64_C(875811540203010669)
              },
              {
                /* 65*/ UINT64_C(12159424758098976503), UINT64_C(1094764425253763336)
              },
              {
                /* 66*/ UINT64_C(7599640473811860314), UINT64_C(684227765783602085)
              },
              {
                /* 67*/ UINT64_C(14111236610692213297), UINT64_C(855284707229502606)
              },
              {
                /* 68*/ UINT64_C(8415673726510490813), UINT64_C(1069105884036878258)
              },
              {
                /* 69*/ UINT64_C(9871482097496444662), UINT64_C(668191177523048911)
              },
              {
                /* 70*/ UINT64_C(7727666603443167924), UINT64_C(835238971903811139)
              },
              {
                /* 71*/ UINT64_C(5047897235876572001), UINT64_C(1044048714879763924)
              },
              {
                /* 72*/ UINT64_C(12378307809277633308), UINT64_C(652530446799852452)
              },
              {
                /* 73*/ UINT64_C(15472884761597041636), UINT64_C(815663058499815565)
              },
              {
                /* 74*/ UINT64_C(5506047896714138333), UINT64_C(1019578823124769457)
              },
              {
                /* 75*/ UINT64_C(14970494981514806218), UINT64_C(637236764452980910)
              },
              {
                /* 76*/ UINT64_C(9489746690038731964), UINT64_C(796545955566226138)
              },
              {
                /* 77*/ UINT64_C(2638811325693639147), UINT64_C(995682444457782673)
              },
              {
                /* 78*/ UINT64_C(13178472124626994227), UINT64_C(622301527786114170)
              },
              {
                /* 79*/ UINT64_C(7249718118928966976), UINT64_C(777876909732642713)
              },
              {
                /* 80*/ UINT64_C(13673833667088596624), UINT64_C(972346137165803391)
              },
              {
                /* 81*/ UINT64_C(15463675069571454746), UINT64_C(607716335728627119)
              },
              {
                /* 82*/ UINT64_C(14717907818536930528), UINT64_C(759645419660783899)
              },
              {
                /* 83*/ UINT64_C(13785698754743775257), UINT64_C(949556774575979874)
              },
              {
                /* 84*/ UINT64_C(13227747740142247439), UINT64_C(593472984109987421)
              },
              {
                /* 85*/ UINT64_C(2699626619895645587), UINT64_C(741841230137484277)
              },
              {
                /* 86*/ UINT64_C(7986219293296944888), UINT64_C(927301537671855346)
              },
              {
                /* 87*/ UINT64_C(9603073076737978459), UINT64_C(579563461044909591)
              },
              {
                /* 88*/ UINT64_C(7392155327495085170), UINT64_C(724454326306136989)
              },
              {
                /* 89*/ UINT64_C(13851880177796244366), UINT64_C(905567907882671236)
              },
              {
                /* 90*/ UINT64_C(17314850222245305458), UINT64_C(1131959884853339045)
              },
              {
                /* 91*/ UINT64_C(13127624398117009863), UINT64_C(707474928033336903)
              },
              {
                /* 92*/ UINT64_C(11797844479218874425), UINT64_C(884343660041671129)
              },
              {
                /* 93*/ UINT64_C(912247543741429319), UINT64_C(1105429575052088912)
              },
              {
                /* 94*/ UINT64_C(570154714838393324), UINT64_C(690893484407555570)
              },
              {
                /* 95*/ UINT64_C(9936065430402767463), UINT64_C(863616855509444462)
              },
              {
                /* 96*/ UINT64_C(3196709751148683521), UINT64_C(1079521069386805578)
              },
              {
                /* 97*/ UINT64_C(6609629612895315105), UINT64_C(674700668366753486)
              },
              {
                /* 98*/ UINT64_C(17485409052973919689), UINT64_C(843375835458441857)
              },
              {
                /* 99*/ UINT64_C(8021703260935235899), UINT64_C(1054219794323052322)
              },
              {
                /*100*/ UINT64_C(9625250556511910341), UINT64_C(658887371451907701)
              },
              {
                /*101*/ UINT64_C(16643249214067275830), UINT64_C(823609214314884626)
              },
              {
                /*102*/ UINT64_C(11580689480729318980), UINT64_C(1029511517893605783)
              },
              {
                /*103*/ UINT64_C(14155459953096906218), UINT64_C(643444698683503614)
              },
              {
                /*104*/ UINT64_C(8470952904516356965), UINT64_C(804305873354379518)
              },
              {
                /*105*/ UINT64_C(1365319093790670398), UINT64_C(1005382341692974398)
              },
              {
                /*106*/ UINT64_C(14688382488901332711), UINT64_C(628363963558108998)
              },
              {
                /*107*/ UINT64_C(9137106074271890081), UINT64_C(785454954447636248)
              },
              {
                /*108*/ UINT64_C(11421382592839862601), UINT64_C(981818693059545310)
              },
              {
                /*109*/ UINT64_C(2526678102097526221), UINT64_C(613636683162215819)
              },
              {
                /*110*/ UINT64_C(16993405682904071489), UINT64_C(767045853952769773)
              },
              {
                /*111*/ UINT64_C(7406699048347925649), UINT64_C(958807317440962217)
              },
              {
                /*112*/ UINT64_C(16158401951285923291), UINT64_C(599254573400601385)
              },
              {
                /*113*/ UINT64_C(6362944383825240401), UINT64_C(749068216750751732)
              },
              {
                /*114*/ UINT64_C(7953680479781550502), UINT64_C(936335270938439665)
              },
              {
                /*115*/ UINT64_C(16500265345931938823), UINT64_C(585209544336524790)
              },
              {
                /*116*/ UINT64_C(11401959645560147721), UINT64_C(731511930420655988)
              },
              {
                /*117*/ UINT64_C(14252449556950184652), UINT64_C(914389913025819985)
              },
              {
                /*118*/ UINT64_C(3980503890905567103), UINT64_C(1142987391282274982)
              },
              {
                /*119*/ UINT64_C(16322872987098143151), UINT64_C(714367119551421863)
              },
              {
                /*120*/ UINT64_C(15791905215445291035), UINT64_C(892958899439277329)
              },
              {
                /*121*/ UINT64_C(5904823464024450082), UINT64_C(1116198624299096662)
              },
              {
                /*122*/ UINT64_C(17525572720297445013), UINT64_C(697624140186935413)
              },
              {
                /*123*/ UINT64_C(8071907845089642554), UINT64_C(872030175233669267)
              },
              {
                /*124*/ UINT64_C(5478198787934665289), UINT64_C(1090037719042086584)
              },
              {
                /*125*/ UINT64_C(3423874242459165806), UINT64_C(681273574401304115)
              },
              {
                /*126*/ UINT64_C(18114900858356120969), UINT64_C(851591968001630143)
              },
              {
                /*127*/ UINT64_C(18031940054517763307), UINT64_C(1064489960002037679)
              },
              {
                /*128*/ UINT64_C(18187491561714683923), UINT64_C(665306225001273549)
              },
              {
                /*129*/ UINT64_C(8899306396861191192), UINT64_C(831632781251591937)
              },
              {
                /*130*/ UINT64_C(15735819014503876894), UINT64_C(1039540976564489921)
              },
              {
                /*131*/ UINT64_C(2917357856423841202), UINT64_C(649713110352806201)
              },
              {
                /*132*/ UINT64_C(8258383338957189407), UINT64_C(812141387941007751)
              },
              {
                /*133*/ UINT64_C(5711293155269098855), UINT64_C(1015176734926259689)
              },
              {
                /*134*/ UINT64_C(15098773268111656544), UINT64_C(634485459328912305)
              },
              {
                /*135*/ UINT64_C(5038408529857406968), UINT64_C(793106824161140382)
              },
              {
                /*136*/ UINT64_C(15521382699176534519), UINT64_C(991383530201425477)
              },
              {
                /*137*/ UINT64_C(12006707196199028026), UINT64_C(619614706375890923)
              },
              {
                /*138*/ UINT64_C(10396697976821397129), UINT64_C(774518382969863654)
              },
              {
                /*139*/ UINT64_C(3772500434171970603), UINT64_C(968147978712329568)
              },
              {
                /*140*/ UINT64_C(2357812771357481627), UINT64_C(605092486695205980)
              },
              {
                /*141*/ UINT64_C(2947265964196852033), UINT64_C(756365608369007475)
              },
              {
                /*142*/ UINT64_C(17519140510528228754), UINT64_C(945457010461259343)
              },
              {
                /*143*/ UINT64_C(17866991846721224827), UINT64_C(590910631538287089)
              },
              {
                /*144*/ UINT64_C(8498681753119367322), UINT64_C(738638289422858862)
              },
              {
                /*145*/ UINT64_C(1399980154544433344), UINT64_C(923297861778573578)
              },
              {
                /*146*/ UINT64_C(5486673615017658744), UINT64_C(577061163611608486)
              },
              {
                /*147*/ UINT64_C(16081714055626849238), UINT64_C(721326454514510607)
              },
              {
                /*148*/ UINT64_C(15490456551106173644), UINT64_C(901658068143138259)
              },
              {
                /*149*/ UINT64_C(14751384670455329151), UINT64_C(1127072585178922824)
              },
              {
                /*150*/ UINT64_C(9219615419034580719), UINT64_C(704420365736826765)
              },
              {
                /*151*/ UINT64_C(16136205292220613803), UINT64_C(880525457171033456)
              },
              {
                /*152*/ UINT64_C(1723512541566215638), UINT64_C(1100656821463791821)
              },
              {
                /*153*/ UINT64_C(3383038347692578726), UINT64_C(687910513414869888)
              },
              {
                /*154*/ UINT64_C(4228797934615723407), UINT64_C(859888141768587360)
              },
              {
                /*155*/ UINT64_C(5285997418269654259), UINT64_C(1074860177210734200)
              },
              {
                /*156*/ UINT64_C(3303748386418533912), UINT64_C(671787610756708875)
              },
              {
                /*157*/ UINT64_C(17964743538305331102), UINT64_C(839734513445886093)
              },
              {
                /*158*/ UINT64_C(8620871367599500165), UINT64_C(1049668141807357617)
              },
              {
                /*159*/ UINT64_C(16917259650818157363), UINT64_C(656042588629598510)
              },
              {
                /*160*/ UINT64_C(11923202526667920896), UINT64_C(820053235786998138)
              },
              {
                /*161*/ UINT64_C(5680631121480125312), UINT64_C(1025066544733747673)
              },
              {
                /*162*/ UINT64_C(15079609496993548080), UINT64_C(640666590458592295)
              },
              {
                /*163*/ UINT64_C(14237825852814547196), UINT64_C(800833238073240369)
              },
              {
                /*164*/ UINT64_C(3962224260736020283), UINT64_C(1001041547591550462)
              },
              {
                /*165*/ UINT64_C(16311448218242176389), UINT64_C(625650967244719038)
              },
              {
                /*166*/ UINT64_C(11165938235947944678), UINT64_C(782063709055898798)
              },
              {
                /*167*/ UINT64_C(4734050758080155040), UINT64_C(977579636319873498)
              },
              {
                /*168*/ UINT64_C(7570467742227484804), UINT64_C(610987272699920936)
              },
              {
                /*169*/ UINT64_C(9463084677784356005), UINT64_C(763734090874901170)
              },
              {
                /*170*/ UINT64_C(2605483810375669198), UINT64_C(954667613593626463)
              },
              {
                /*171*/ UINT64_C(8545956409125875105), UINT64_C(596667258496016539)
              },
              {
                /*172*/ UINT64_C(6070759492979955977), UINT64_C(745834073120020674)
              },
              {
                /*173*/ UINT64_C(16811821403079720779), UINT64_C(932292591400025842)
              },
              {
                /*174*/ UINT64_C(15119074395352213391), UINT64_C(582682869625016151)
              },
              {
                /*175*/ UINT64_C(14287156975762878835), UINT64_C(728353587031270189)
              },
              {
                /*176*/ UINT64_C(4023888164421434831), UINT64_C(910441983789087737)
              },
              {
                /*177*/ UINT64_C(9641546223954181443), UINT64_C(1138052479736359671)
              },
              {
                /*178*/ UINT64_C(12943495417612445258), UINT64_C(711282799835224794)
              },
              {
                /*179*/ UINT64_C(6955997235160780765), UINT64_C(889103499794030993)
              },
              {
                /*180*/ UINT64_C(13306682562378363860), UINT64_C(1111379374742538741)
              },
              {
                /*181*/ UINT64_C(10622519610700171364), UINT64_C(694612109214086713)
              },
              {
                /*182*/ UINT64_C(17889835531802602109), UINT64_C(868265136517608391)
              },
              {
                /*183*/ UINT64_C(17750608396325864733), UINT64_C(1085331420647010489)
              },
              {
                /*184*/ UINT64_C(4176601220062583602), UINT64_C(678332137904381556)
              },
              {
                /*185*/ UINT64_C(5220751525078229502), UINT64_C(847915172380476945)
              },
              {
                /*186*/ UINT64_C(11137625424775174782), UINT64_C(1059893965475596181)
              },
              {
                /*187*/ UINT64_C(9266858899698178191), UINT64_C(662433728422247613)
              },
              {
                /*188*/ UINT64_C(16195259643050110642), UINT64_C(828042160527809516)
              },
              {
                /*189*/ UINT64_C(1797330480103086687), UINT64_C(1035052700659761896)
              },
              {
                /*190*/ UINT64_C(1123331550064429179), UINT64_C(646907937912351185)
              },
              {
                /*191*/ UINT64_C(6015850456007924378), UINT64_C(808634922390438981)
              },
              {
                /*192*/ UINT64_C(12131499088437293377), UINT64_C(1010793652988048726)
              },
              {
                /*193*/ UINT64_C(2970500911845920456), UINT64_C(631746033117530454)
              },
              {
                /*194*/ UINT64_C(12936498176662176379), UINT64_C(789682541396913067)
              },
              {
                /*195*/ UINT64_C(11558936702400332569), UINT64_C(987103176746141334)
              },
              {
                /*196*/ UINT64_C(2612649420572819952), UINT64_C(616939485466338334)
              },
              {
                /*197*/ UINT64_C(12489183812570800748), UINT64_C(771174356832922917)
              },
              {
                /*198*/ UINT64_C(1776421710431337223), UINT64_C(963967946041153647)
              },
              {
                /*199*/ UINT64_C(8027792596660667620), UINT64_C(602479966275721029)
              },
              {
                /*200*/ UINT64_C(14646426764253222429), UINT64_C(753099957844651286)
              },
              {
                /*201*/ UINT64_C(9084661418461752229), UINT64_C(941374947305814108)
              },
              {
                /*202*/ UINT64_C(14901285423393370951), UINT64_C(588359342066133817)
              },
              {
                /*203*/ UINT64_C(4791548723959549977), UINT64_C(735449177582667272)
              },
              {
                /*204*/ UINT64_C(5989435904949437471), UINT64_C(919311471978334090)
              },
              {
                /*205*/ UINT64_C(16710166918041572647), UINT64_C(1149139339972917612)
              },
              {
                /*206*/ UINT64_C(1220482286921207096), UINT64_C(718212087483073508)
              },
              {
                /*207*/ UINT64_C(1525602858651508870), UINT64_C(897765109353841885)
              },
              {
                /*208*/ UINT64_C(6518689591741773992), UINT64_C(1122206386692302356)
              },
              {
                /*209*/ UINT64_C(13297553031693384553), UINT64_C(701378991682688972)
              },
              {
                /*210*/ UINT64_C(16621941289616730691), UINT64_C(876723739603361215)
              },
              {
                /*211*/ UINT64_C(16165740593593525460), UINT64_C(1095904674504201519)
              },
              {
                /*212*/ UINT64_C(17021116898637035268), UINT64_C(684940421565125949)
              },
              {
                /*213*/ UINT64_C(7441338068014130373), UINT64_C(856175526956407437)
              },
              {
                /*214*/ UINT64_C(13913358603445050871), UINT64_C(1070219408695509296)
              },
              {
                /*215*/ UINT64_C(8695849127153156794), UINT64_C(668887130434693310)
              },
              {
                /*216*/ UINT64_C(1646439372086670185), UINT64_C(836108913043366638)
              },
              {
                /*217*/ UINT64_C(11281421251963113539), UINT64_C(1045136141304208297)
              },
              {
                /*218*/ UINT64_C(133359254835864106), UINT64_C(653210088315130186)
              },
              {
                /*219*/ UINT64_C(9390071105399605940), UINT64_C(816512610393912732)
              },
              {
                /*220*/ UINT64_C(11737588881749507425), UINT64_C(1020640762992390915)
              },
              {
                /*221*/ UINT64_C(5030150041879748189), UINT64_C(637900476870244322)
              },
              {
                /*222*/ UINT64_C(15511059589204461044), UINT64_C(797375596087805402)
              },
              {
                /*223*/ UINT64_C(10165452449650800497), UINT64_C(996719495109756753)
              },
              {
                /*224*/ UINT64_C(17882622827100220070), UINT64_C(622949684443597970)
              },
              {
                /*225*/ UINT64_C(13129906497020499280), UINT64_C(778687105554497463)
              },
              {
                /*226*/ UINT64_C(11800697102848236196), UINT64_C(973358881943121829)
              },
              {
                /*227*/ UINT64_C(9681278698493841575), UINT64_C(608349301214451143)
              },
              {
                /*228*/ UINT64_C(7489912354689914064), UINT64_C(760436626518063929)
              },
              {
                /*229*/ UINT64_C(13974076461789780485), UINT64_C(950545783147579911)
              },
              {
                /*230*/ UINT64_C(15651326816259694659), UINT64_C(594091114467237444)
              },
              {
                /*231*/ UINT64_C(1117414446615066707), UINT64_C(742613893084046806)
              },
              {
                /*232*/ UINT64_C(10620140095123609192), UINT64_C(928267366355058507)
              },
              {
                /*233*/ UINT64_C(4331744550238561793), UINT64_C(580167103971911567)
              },
              {
                /*234*/ UINT64_C(802994669370814337), UINT64_C(725208879964889459)
              },
              {
                /*235*/ UINT64_C(14838801391995681634), UINT64_C(906511099956111823)
              },
              {
                /*236*/ UINT64_C(13936815721567214139), UINT64_C(1133138874945139779)
              },
              {
                /*237*/ UINT64_C(6404666816765814884), UINT64_C(708211796840712362)
              },
              {
                /*238*/ UINT64_C(17229205557812044414), UINT64_C(885264746050890452)
              },
              {
                /*239*/ UINT64_C(3089762873555503901), UINT64_C(1106580932563613066)
              },
              {
                /*240*/ UINT64_C(6542787814399577842), UINT64_C(691613082852258166)
              },
              {
                /*241*/ UINT64_C(17401856804854248111), UINT64_C(864516353565322707)
              },
              {
                /*242*/ UINT64_C(17140634987640422235), UINT64_C(1080645441956653384)
              },
              {
                /*243*/ UINT64_C(10712896867275263896), UINT64_C(675403401222908365)
              },
              {
                /*244*/ UINT64_C(18002807102521467775), UINT64_C(844254251528635456)
              },
              {
                /*245*/ UINT64_C(4056764804442283102), UINT64_C(1055317814410794321)
              },
              {
                /*246*/ UINT64_C(14064693048844896699), UINT64_C(659573634006746450)
              },
              {
                /*247*/ UINT64_C(8357494274201345066), UINT64_C(824467042508433063)
              },
              {
                /*248*/ UINT64_C(5835181824324293428), UINT64_C(1030583803135541329)
              },
              {
                /*249*/ UINT64_C(15176203686271153152), UINT64_C(644114876959713330)
              },
              {
                /*250*/ UINT64_C(9746882570984165633), UINT64_C(805143596199641663)
              },
              {
                /*251*/ UINT64_C(7571917195302819137), UINT64_C(1006429495249552079)
              },
              {
                /*252*/ UINT64_C(11649977274705343816), UINT64_C(629018434530970049)
              },
              {
                /*253*/ UINT64_C(727413538099516059), UINT64_C(786273043163712562)
              },
              {
                /*254*/ UINT64_C(10132638959479170881), UINT64_C(982841303954640702)
              },
              {
                /*255*/ UINT64_C(1721213331247093897), UINT64_C(614275814971650439)
              },
              {
                /*256*/ UINT64_C(15986574719341031083), UINT64_C(767844768714563048)
              },
              {
                /*257*/ UINT64_C(1536474325466737238), UINT64_C(959805960893203811)
              },
              {
                /*258*/ UINT64_C(17101197517912568437), UINT64_C(599878725558252381)
              },
              {
                /*259*/ UINT64_C(7541438842108546835), UINT64_C(749848406947815477)
              },
              {
                /*260*/ UINT64_C(14038484571063071448), UINT64_C(937310508684769346)
              },
              {
                /*261*/ UINT64_C(13385738875341807559), UINT64_C(585819067927980841)
              },
              {
                /*262*/ UINT64_C(2897115538895095736), UINT64_C(732273834909976052)
              },
              {
                /*263*/ UINT64_C(3621394423618869671), UINT64_C(915342293637470065)
              },
              {
                /*264*/ UINT64_C(9138429047950974993), UINT64_C(1144177867046837581)
              },
              {
                /*265*/ UINT64_C(8017361164183053322), UINT64_C(715111166904273488)
              },
              {
                /*266*/ UINT64_C(10021701455228816653), UINT64_C(893888958630341860)
              },
              {
                /*267*/ UINT64_C(12527126819036020816), UINT64_C(1117361198287927325)
              },
              {
                /*268*/ UINT64_C(10135297271111206962), UINT64_C(698350748929954578)
              },
              {
                /*269*/ UINT64_C(3445749552034232895), UINT64_C(872938436162443223)
              },
              {
                /*270*/ UINT64_C(18142244995324954830), UINT64_C(1091173045203054028)
              },
              {
                /*271*/ UINT64_C(2115531085223320961), UINT64_C(681983153251908768)
              },
              {
                /*272*/ UINT64_C(2644413856529151201), UINT64_C(852478941564885960)
              },
              {
                /*273*/ UINT64_C(3305517320661439001), UINT64_C(1065598676956107450)
              },
              {
                /*274*/ UINT64_C(6677634343840787280), UINT64_C(665999173097567156)
              },
              {
                /*275*/ UINT64_C(8347042929800984100), UINT64_C(832498966371958945)
              },
              {
                /*276*/ UINT64_C(15045489680678618029), UINT64_C(1040623707964948681)
              },
              {
                /*277*/ UINT64_C(2485902022783054412), UINT64_C(650389817478092926)
              },
              {
                /*278*/ UINT64_C(12330749565333593823), UINT64_C(812987271847616157)
              },
              {
                /*279*/ UINT64_C(1578378901384828567), UINT64_C(1016234089809520197)
              },
              {
                /*280*/ UINT64_C(3292329822579211806), UINT64_C(635146306130950123)
              },
              {
                /*281*/ UINT64_C(17950470333506178470), UINT64_C(793932882663687653)
              },
              {
                /*282*/ UINT64_C(8603029861600559375), UINT64_C(992416103329609567)
              },
              {
                /*283*/ UINT64_C(12294422691141431465), UINT64_C(620260064581005979)
              },
              {
                /*284*/ UINT64_C(10756342345499401428), UINT64_C(775325080726257474)
              },
              {
                /*285*/ UINT64_C(4222055895019475977), UINT64_C(969156350907821843)
              },
              {
                /*286*/ UINT64_C(332941925173478533), UINT64_C(605722719317388652)
              },
              {
                /*287*/ UINT64_C(416177406466848167), UINT64_C(757153399146735815)
              },
              {
                /*288*/ UINT64_C(14355279813365723921), UINT64_C(946441748933419768)
              },
              {
                /*289*/ UINT64_C(8972049883353577450), UINT64_C(591526093083387355)
              },
              {
                /*290*/ UINT64_C(6603376335764583909), UINT64_C(739407616354234194)
              },
              {
                /*291*/ UINT64_C(17477592456560505694), UINT64_C(924259520442792742)
              },
              {
                /*292*/ UINT64_C(6311809266922928155), UINT64_C(577662200276745464)
              },
              {
                /*293*/ UINT64_C(7889761583653660193), UINT64_C(722077750345931830)
              },
              {
                /*294*/ UINT64_C(638829942712299434), UINT64_C(902597187932414788)
              },
              {
                /*295*/ UINT64_C(798537428390374293), UINT64_C(1128246484915518485)
              },
              {
                /*296*/ UINT64_C(2804928901957677885), UINT64_C(705154053072199053)
              },
              {
                /*297*/ UINT64_C(8117847145874485260), UINT64_C(881442566340248816)
              },
              {
                /*298*/ UINT64_C(10147308932343106575), UINT64_C(1101803207925311020)
              },
              {
                /*299*/ UINT64_C(15565440119569217417), UINT64_C(688627004953319387)
              },
              {
                /*300*/ UINT64_C(14845114131034133868), UINT64_C(860783756191649234)
              },
              {
                /*301*/ UINT64_C(9333020626937891527), UINT64_C(1075979695239561543)
              },
              {
                /*302*/ UINT64_C(12750666919477264060), UINT64_C(672487309524725964)
              },
              {
                /*303*/ UINT64_C(15938333649346580075), UINT64_C(840609136905907455)
              },
              {
                /*304*/ UINT64_C(15311231043255837190), UINT64_C(1050761421132384319)
              },
              {
                /*305*/ UINT64_C(16487048429675980100), UINT64_C(656725888207740199)
              },
              {
                /*306*/ UINT64_C(15997124518667587221), UINT64_C(820907360259675249)
              },
              {
                /*307*/ UINT64_C(6161347593052320314), UINT64_C(1026134200324594062)
              },
              {
                /*308*/ UINT64_C(17685900300939863908), UINT64_C(641333875202871288)
              },
              {
                /*309*/ UINT64_C(3660631302465278269), UINT64_C(801667344003589111)
              },
              {
                /*310*/ UINT64_C(18410847183363761549), UINT64_C(1002084180004486388)
              },
              {
                /*311*/ UINT64_C(2283407452747575160), UINT64_C(626302612502803993)
              },
              {
                /*312*/ UINT64_C(7465945334361856854), UINT64_C(782878265628504991)
              },
              {
                /*313*/ UINT64_C(4720745649524933163), UINT64_C(978597832035631239)
              },
              {
                /*314*/ UINT64_C(9867995058594165083), UINT64_C(611623645022269524)
              },
              {
                /*315*/ UINT64_C(12334993823242706354), UINT64_C(764529556277836905)
              },
              {
                /*316*/ UINT64_C(1583684223771219230), UINT64_C(955661945347296132)
              },
              {
                /*317*/ UINT64_C(10213174676711787827), UINT64_C(597288715842060082)
              },
              {
                /*318*/ UINT64_C(3543096309034958976), UINT64_C(746610894802575103)
              },
              {
                /*319*/ UINT64_C(18263928441575862432), UINT64_C(933263618503218878)
              },
              {
                /*320*/ UINT64_C(6803269257557526116), UINT64_C(583289761564511799)
              },
              {
                /*321*/ UINT64_C(3892400553519519741), UINT64_C(729112201955639749)
              },
              {
                /*322*/ UINT64_C(9477186710326787580), UINT64_C(911390252444549686)
              },
              {
                /*323*/ UINT64_C(2623111351053708667), UINT64_C(1139237815555687108)
              },
              {
                /*324*/ UINT64_C(10862816631263343725), UINT64_C(712023634722304442)
              },
              {
                /*325*/ UINT64_C(4355148752224403848), UINT64_C(890029543402880553)
              }
            };
            return &data[index][0];
          }

          static const uint64_t *greater_than_equals(int index) {
            static const uint64_t data[291][2] = {
              {
                /*  0*/ UINT64_C(0), UINT64_C(1152921504606846976)
              },
              {
                /*  1*/ UINT64_C(14757395258967641292), UINT64_C(922337203685477580)
              },
              {
                /*  2*/ UINT64_C(11805916207174113034), UINT64_C(737869762948382064)
              },
              {
                /*  3*/ UINT64_C(13134081780481200750), UINT64_C(590295810358705651)
              },
              {
                /*  4*/ UINT64_C(13635833219286100554), UINT64_C(944473296573929042)
              },
              {
                /*  5*/ UINT64_C(3529968945945059797), UINT64_C(755578637259143234)
              },
              {
                /*  6*/ UINT64_C(6513323971497958160), UINT64_C(604462909807314587)
              },
              {
                /*  7*/ UINT64_C(14110667169138643380), UINT64_C(967140655691703339)
              },
              {
                /*  8*/ UINT64_C(14977882550052825027), UINT64_C(773712524553362671)
              },
              {
                /*  9*/ UINT64_C(8292957225300349699), UINT64_C(618970019642690137)
              },
              {
                /* 10*/ UINT64_C(16958080375222469841), UINT64_C(990352031428304219)
              },
              {
                /* 11*/ UINT64_C(17255813114919886196), UINT64_C(792281625142643375)
              },
              {
                /* 12*/ UINT64_C(13804650491935908957), UINT64_C(633825300114114700)
              },
              {
                /* 13*/ UINT64_C(3640696713387902715), UINT64_C(1014120480182583521)
              },
              {
                /* 14*/ UINT64_C(17669952629677963465), UINT64_C(811296384146066816)
              },
              {
                /* 15*/ UINT64_C(10446613289000460449), UINT64_C(649037107316853453)
              },
              {
                /* 16*/ UINT64_C(13025232447658826395), UINT64_C(1038459371706965525)
              },
              {
                /* 17*/ UINT64_C(10420185958127061116), UINT64_C(830767497365572420)
              },
              {
                /* 18*/ UINT64_C(8336148766501648892), UINT64_C(664613997892457936)
              },
              {
                /* 19*/ UINT64_C(5959140396918817582), UINT64_C(1063382396627932698)
              },
              {
                /* 20*/ UINT64_C(12146009947018874712), UINT64_C(850705917302346158)
              },
              {
                /* 21*/ UINT64_C(17095505587098920416), UINT64_C(680564733841876926)
              },
              {
                /* 22*/ UINT64_C(1527367236164900403), UINT64_C(1088903574147003083)
              },
              {
                /* 23*/ UINT64_C(8600591418415740969), UINT64_C(871122859317602466)
              },
              {
                /* 24*/ UINT64_C(3191124319990682452), UINT64_C(696898287454081973)
              },
              {
                /* 25*/ UINT64_C(1416450097243181600), UINT64_C(1115037259926531157)
              },
              {
                /* 26*/ UINT64_C(12201206522020276249), UINT64_C(892029807941224925)
              },
              {
                /* 27*/ UINT64_C(9760965217616220999), UINT64_C(713623846352979940)
              },
              {
                /* 28*/ UINT64_C(15617544348185953599), UINT64_C(1141798154164767904)
              },
              {
                /* 29*/ UINT64_C(16183384293290673203), UINT64_C(913438523331814323)
              },
              {
                /* 30*/ UINT64_C(1878660990406807592), UINT64_C(730750818665451459)
              },
              {
                /* 31*/ UINT64_C(5192277607067356397), UINT64_C(584600654932361167)
              },
              {
                /* 32*/ UINT64_C(11996992986049680559), UINT64_C(935361047891777867)
              },
              {
                /* 33*/ UINT64_C(2218896759355923800), UINT64_C(748288838313422294)
              },
              {
                /* 34*/ UINT64_C(5464466222226649363), UINT64_C(598631070650737835)
              },
              {
                /* 35*/ UINT64_C(8743145955562638982), UINT64_C(957809713041180536)
              },
              {
                /* 36*/ UINT64_C(3305167949708200862), UINT64_C(766247770432944429)
              },
              {
                /* 37*/ UINT64_C(6333483174508471013), UINT64_C(612998216346355543)
              },
              {
                /* 38*/ UINT64_C(6444224264471643298), UINT64_C(980797146154168869)
              },
              {
                /* 39*/ UINT64_C(8844728226319224961), UINT64_C(784637716923335095)
              },
              {
                /* 40*/ UINT64_C(7075782581055379969), UINT64_C(627710173538668076)
              },
              {
                /* 41*/ UINT64_C(3942554500204787304), UINT64_C(1004336277661868922)
              },
              {
                /* 42*/ UINT64_C(14222090044389560813), UINT64_C(803469022129495137)
              },
              {
                /* 43*/ UINT64_C(3998974406027828004), UINT64_C(642775217703596110)
              },
              {
                /* 44*/ UINT64_C(6398359049644524806), UINT64_C(1028440348325753776)
              },
              {
                /* 45*/ UINT64_C(1429338424973709522), UINT64_C(822752278660603021)
              },
              {
                /* 46*/ UINT64_C(15900865998946608910), UINT64_C(658201822928482416)
              },
              {
                /* 47*/ UINT64_C(18062687968830753610), UINT64_C(1053122916685571866)
              },
              {
                /* 48*/ UINT64_C(10760801560322692565), UINT64_C(842498333348457493)
              },
              {
                /* 49*/ UINT64_C(15987338877741974698), UINT64_C(673998666678765994)
              },
              {
                /* 50*/ UINT64_C(14511695760161428548), UINT64_C(1078397866686025591)
              },
              {
                /* 51*/ UINT64_C(7920007793387232515), UINT64_C(862718293348820473)
              },
              {
                /* 52*/ UINT64_C(13714703864193606658), UINT64_C(690174634679056378)
              },
              {
                /* 53*/ UINT64_C(18254177367967860330), UINT64_C(1104279415486490205)
              },
              {
                /* 54*/ UINT64_C(14603341894374288264), UINT64_C(883423532389192164)
              },
              {
                /* 55*/ UINT64_C(15372022330241340934), UINT64_C(706738825911353731)
              },
              {
                /* 56*/ UINT64_C(17216538098902324849), UINT64_C(1130782121458165970)
              },
              {
                /* 57*/ UINT64_C(13773230479121859879), UINT64_C(904625697166532776)
              },
              {
                /* 58*/ UINT64_C(7329235568555577580), UINT64_C(723700557733226221)
              },
              {
                /* 59*/ UINT64_C(2174039640102551741), UINT64_C(578960446186580977)
              },
              {
                /* 60*/ UINT64_C(7167812238905993108), UINT64_C(926336713898529563)
              },
              {
                /* 61*/ UINT64_C(13112947420608615133), UINT64_C(741069371118823650)
              },
              {
                /* 62*/ UINT64_C(10490357936486892106), UINT64_C(592855496895058920)
              },
              {
                /* 63*/ UINT64_C(16784572698379027370), UINT64_C(948568795032094272)
              },
              {
                /* 64*/ UINT64_C(6048960529219401250), UINT64_C(758855036025675418)
              },
              {
                /* 65*/ UINT64_C(12217866052859341646), UINT64_C(607084028820540334)
              },
              {
                /* 66*/ UINT64_C(8480539240349215664), UINT64_C(971334446112864535)
              },
              {
                /* 67*/ UINT64_C(6784431392279372531), UINT64_C(777067556890291628)
              },
              {
                /* 68*/ UINT64_C(12806242743307318671), UINT64_C(621654045512233302)
              },
              {
                /* 69*/ UINT64_C(5732593130324068582), UINT64_C(994646472819573284)
              },
              {
                /* 70*/ UINT64_C(8275423319001165189), UINT64_C(795717178255658627)
              },
              {
                /* 71*/ UINT64_C(17688385099426663120), UINT64_C(636573742604526901)
              },
              {
                /* 72*/ UINT64_C(2475974455889288731), UINT64_C(1018517988167243043)
              },
              {
                /* 73*/ UINT64_C(9359477194195251631), UINT64_C(814814390533794434)
              },
              {
                /* 74*/ UINT64_C(11176930570098111628), UINT64_C(651851512427035547)
              },
              {
                /* 75*/ UINT64_C(3125693653189337312), UINT64_C(1042962419883256876)
              },
              {
                /* 76*/ UINT64_C(17257950181519111142), UINT64_C(834369935906605500)
              },
              {
                /* 77*/ UINT64_C(13806360145215288914), UINT64_C(667495948725284400)
              },
              {
                /* 78*/ UINT64_C(3643432158634910646), UINT64_C(1067993517960455041)
              },
              {
                /* 79*/ UINT64_C(17672140985875569810), UINT64_C(854394814368364032)
              },
              {
                /* 80*/ UINT64_C(6759015159216635201), UINT64_C(683515851494691226)
              },
              {
                /* 81*/ UINT64_C(3435726625262795676), UINT64_C(1093625362391505962)
              },
              {
                /* 82*/ UINT64_C(13816627744435967510), UINT64_C(874900289913204769)
              },
              {
                /* 83*/ UINT64_C(14742651010290684331), UINT64_C(699920231930563815)
              },
              {
                /* 84*/ UINT64_C(5141497542755543314), UINT64_C(1119872371088902105)
              },
              {
                /* 85*/ UINT64_C(4113198034204434651), UINT64_C(895897896871121684)
              },
              {
                /* 86*/ UINT64_C(6979907242105458044), UINT64_C(716718317496897347)
              },
              {
                /* 87*/ UINT64_C(14857200402110643194), UINT64_C(1146749307995035755)
              },
              {
                /* 88*/ UINT64_C(11885760321688514555), UINT64_C(917399446396028604)
              },
              {
                /* 89*/ UINT64_C(13197957072092721967), UINT64_C(733919557116822883)
              },
              {
                /* 90*/ UINT64_C(17937063287157998220), UINT64_C(587135645693458306)
              },
              {
                /* 91*/ UINT64_C(2873859556259424890), UINT64_C(939417033109533291)
              },
              {
                /* 92*/ UINT64_C(17056482903975181205), UINT64_C(751533626487626632)
              },
              {
                /* 93*/ UINT64_C(6266488693696324317), UINT64_C(601226901190101306)
              },
              {
                /* 94*/ UINT64_C(2647684280430298261), UINT64_C(961963041904162090)
              },
              {
                /* 95*/ UINT64_C(2118147424344238609), UINT64_C(769570433523329672)
              },
              {
                /* 96*/ UINT64_C(12762564383701121857), UINT64_C(615656346818663737)
              },
              {
                /* 97*/ UINT64_C(5662707754954153678), UINT64_C(985050154909861980)
              },
              {
                /* 98*/ UINT64_C(4530166203963322943), UINT64_C(788040123927889584)
              },
              {
                /* 99*/ UINT64_C(7313481777912568677), UINT64_C(630432099142311667)
              },
              {
                /*100*/ UINT64_C(15390919659402020207), UINT64_C(1008691358627698667)
              },
              {
                /*101*/ UINT64_C(4934038098037795519), UINT64_C(806953086902158934)
              },
              {
                /*102*/ UINT64_C(7636579293172146738), UINT64_C(645562469521727147)
              },
              {
                /*103*/ UINT64_C(15907875683817345105), UINT64_C(1032899951234763435)
              },
              {
                /*104*/ UINT64_C(12726300547053876084), UINT64_C(826319960987810748)
              },
              {
                /*105*/ UINT64_C(17559738067126921513), UINT64_C(661055968790248598)
              },
              {
                /*106*/ UINT64_C(5959488018951612482), UINT64_C(1057689550064397758)
              },
              {
                /*107*/ UINT64_C(12146288044645110632), UINT64_C(846151640051518206)
              },
              {
                /*108*/ UINT64_C(6027681620974178182), UINT64_C(676921312041214565)
              },
              {
                /*109*/ UINT64_C(9644290593558685092), UINT64_C(1083074099265943304)
              },
              {
                /*110*/ UINT64_C(11404781289588858397), UINT64_C(866459279412754643)
              },
              {
                /*111*/ UINT64_C(16502522661154907364), UINT64_C(693167423530203714)
              },
              {
                /*112*/ UINT64_C(15335989813622120813), UINT64_C(1109067877648325943)
              },
              {
                /*113*/ UINT64_C(1200745406671965681), UINT64_C(887254302118660755)
              },
              {
                /*114*/ UINT64_C(960596325337572544), UINT64_C(709803441694928604)
              },
              {
                /*115*/ UINT64_C(8915651750023936718), UINT64_C(1135685506711885766)
              },
              {
                /*116*/ UINT64_C(3443172585277239051), UINT64_C(908548405369508613)
              },
              {
                /*117*/ UINT64_C(10133235697705611887), UINT64_C(726838724295606890)
              },
              {
                /*118*/ UINT64_C(8106588558164489509), UINT64_C(581470979436485512)
              },
              {
                /*119*/ UINT64_C(16659890507805093539), UINT64_C(930353567098376819)
              },
              {
                /*120*/ UINT64_C(17017261220985985154), UINT64_C(744282853678701455)
              },
              {
                /*121*/ UINT64_C(13613808976788788123), UINT64_C(595426282942961164)
              },
              {
                /*122*/ UINT64_C(10714047918636330028), UINT64_C(952682052708737863)
              },
              {
                /*123*/ UINT64_C(15949935964392884668), UINT64_C(762145642166990290)
              },
              {
                /*124*/ UINT64_C(12759948771514307735), UINT64_C(609716513733592232)
              },
              {
                /*125*/ UINT64_C(5658522775455251083), UINT64_C(975546421973747572)
              },
              {
                /*126*/ UINT64_C(15594864664589931836), UINT64_C(780437137578998057)
              },
              {
                /*127*/ UINT64_C(5097194102188124822), UINT64_C(624349710063198446)
              },
              {
                /*128*/ UINT64_C(776812934017179069), UINT64_C(998959536101117514)
              },
              {
                /*129*/ UINT64_C(4310799161955653579), UINT64_C(799167628880894011)
              },
              {
                /*130*/ UINT64_C(18206034588532164156), UINT64_C(639334103104715208)
              },
              {
                /*131*/ UINT64_C(6993562453200000710), UINT64_C(1022934564967544334)
              },
              {
                /*132*/ UINT64_C(9284198777301910891), UINT64_C(818347651974035467)
              },
              {
                /*133*/ UINT64_C(48661392357708066), UINT64_C(654678121579228374)
              },
              {
                /*134*/ UINT64_C(7456555857256153553), UINT64_C(1047484994526765398)
              },
              {
                /*135*/ UINT64_C(13343942315288743489), UINT64_C(837987995621412318)
              },
              {
                /*136*/ UINT64_C(18053851481714815437), UINT64_C(670390396497129854)
              },
              {
                /*137*/ UINT64_C(17818115926517973730), UINT64_C(1072624634395407767)
              },
              {
                /*138*/ UINT64_C(6875795111730558338), UINT64_C(858099707516326214)
              },
              {
                /*139*/ UINT64_C(9189984904126356993), UINT64_C(686479766013060971)
              },
              {
                /*140*/ UINT64_C(7325278217118350543), UINT64_C(1098367625620897554)
              },
              {
                /*141*/ UINT64_C(9549571388436590758), UINT64_C(878694100496718043)
              },
              {
                /*142*/ UINT64_C(15018354740233093252), UINT64_C(702955280397374434)
              },
              {
                /*143*/ UINT64_C(12961321140147218235), UINT64_C(1124728448635799095)
              },
              {
                /*144*/ UINT64_C(10369056912117774588), UINT64_C(899782758908639276)
              },
              {
                /*145*/ UINT64_C(4605896714952309347), UINT64_C(719826207126911421)
              },
              {
                /*146*/ UINT64_C(18437481188149425925), UINT64_C(1151721931403058273)
              },
              {
                /*147*/ UINT64_C(3681938506293809770), UINT64_C(921377545122446619)
              },
              {
                /*148*/ UINT64_C(6634899619776958139), UINT64_C(737102036097957295)
              },
              {
                /*149*/ UINT64_C(5307919695821566511), UINT64_C(589681628878365836)
              },
              {
                /*150*/ UINT64_C(1113973883830685772), UINT64_C(943490606205385338)
              },
              {
                /*151*/ UINT64_C(8269876736548369264), UINT64_C(754792484964308270)
              },
              {
                /*152*/ UINT64_C(6615901389238695411), UINT64_C(603833987971446616)
              },
              {
                /*153*/ UINT64_C(3206744593298092011), UINT64_C(966134380754314586)
              },
              {
                /*154*/ UINT64_C(17322790933606114902), UINT64_C(772907504603451668)
              },
              {
                /*155*/ UINT64_C(2790186302659160952), UINT64_C(618326003682761335)
              },
              {
                /*156*/ UINT64_C(4464298084254657523), UINT64_C(989321605892418136)
              },
              {
                /*157*/ UINT64_C(18328833726371367311), UINT64_C(791457284713934508)
              },
              {
                /*158*/ UINT64_C(3595020536871362879), UINT64_C(633165827771147607)
              },
              {
                /*159*/ UINT64_C(9441381673736090930), UINT64_C(1013065324433836171)
              },
              {
                /*160*/ UINT64_C(3863756524246962421), UINT64_C(810452259547068937)
              },
              {
                /*161*/ UINT64_C(14159051663623300906), UINT64_C(648361807637655149)
              },
              {
                /*162*/ UINT64_C(11586436217571550481), UINT64_C(1037378892220248239)
              },
              {
                /*163*/ UINT64_C(12958497788799150708), UINT64_C(829903113776198591)
              },
              {
                /*164*/ UINT64_C(6677449416297410243), UINT64_C(663922491020958873)
              },
              {
                /*165*/ UINT64_C(6994570251333946066), UINT64_C(1062275985633534197)
              },
              {
                /*166*/ UINT64_C(16663702645292887822), UINT64_C(849820788506827357)
              },
              {
                /*167*/ UINT64_C(5952264486750489611), UINT64_C(679856630805461886)
              },
              {
                /*168*/ UINT64_C(2144925549316962732), UINT64_C(1087770609288739018)
              },
              {
                /*169*/ UINT64_C(9094638068937390832), UINT64_C(870216487430991214)
              },
              {
                /*170*/ UINT64_C(10965059269891822988), UINT64_C(696173189944792971)
              },
              {
                /*171*/ UINT64_C(10165397202343096135), UINT64_C(1113877103911668754)
              },
              {
                /*172*/ UINT64_C(11821666576616387231), UINT64_C(891101683129335003)
              },
              {
                /*173*/ UINT64_C(16836030890776930431), UINT64_C(712881346503468002)
              },
              {
                /*174*/ UINT64_C(12180254166275447398), UINT64_C(1140610154405548804)
              },
              {
                /*175*/ UINT64_C(13433552147762268241), UINT64_C(912488123524439043)
              },
              {
                /*176*/ UINT64_C(18125539347693635239), UINT64_C(729990498819551234)
              },
              {
                /*177*/ UINT64_C(18189780292896818515), UINT64_C(583992399055640987)
              },
              {
                /*178*/ UINT64_C(14346253209667268331), UINT64_C(934387838489025580)
              },
              {
                /*179*/ UINT64_C(11477002567733814665), UINT64_C(747510270791220464)
              },
              {
                /*180*/ UINT64_C(12870950868928962055), UINT64_C(598008216632976371)
              },
              {
                /*181*/ UINT64_C(13214823760802518641), UINT64_C(956813146612762194)
              },
              {
                /*182*/ UINT64_C(14261207823383925236), UINT64_C(765450517290209755)
              },
              {
                /*183*/ UINT64_C(11408966258707140189), UINT64_C(612360413832167804)
              },
              {
                /*184*/ UINT64_C(7186299569705693333), UINT64_C(979776662131468487)
              },
              {
                /*185*/ UINT64_C(16817086099990285636), UINT64_C(783821329705174789)
              },
              {
                /*186*/ UINT64_C(17143017694734138832), UINT64_C(627057063764139831)
              },
              {
                /*187*/ UINT64_C(1603386608381249869), UINT64_C(1003291302022623731)
              },
              {
                /*188*/ UINT64_C(16040104545672641188), UINT64_C(802633041618098984)
              },
              {
                /*189*/ UINT64_C(16521432451280023273), UINT64_C(642106433294479187)
              },
              {
                /*190*/ UINT64_C(11676896663080395945), UINT64_C(1027370293271166700)
              },
              {
                /*191*/ UINT64_C(9341517330464316756), UINT64_C(821896234616933360)
              },
              {
                /*192*/ UINT64_C(7473213864371453404), UINT64_C(657516987693546688)
              },
              {
                /*193*/ UINT64_C(8267793368252415124), UINT64_C(1052027180309674701)
              },
              {
                /*194*/ UINT64_C(2924885879860021776), UINT64_C(841621744247739761)
              },
              {
                /*195*/ UINT64_C(17097303962855658714), UINT64_C(673297395398191808)
              },
              {
                /*196*/ UINT64_C(5219593452117592003), UINT64_C(1077275832637106894)
              },
              {
                /*197*/ UINT64_C(7865023576435983925), UINT64_C(861820666109685515)
              },
              {
                /*198*/ UINT64_C(6292018861148787140), UINT64_C(689456532887748412)
              },
              {
                /*199*/ UINT64_C(13756578992579969748), UINT64_C(1103130452620397459)
              },
              {
                /*200*/ UINT64_C(14694612008805886121), UINT64_C(882504362096317967)
              },
              {
                /*201*/ UINT64_C(4376991977560888251), UINT64_C(706003489677054374)
              },
              {
                /*202*/ UINT64_C(14381884793581241848), UINT64_C(1129605583483286998)
              },
              {
                /*203*/ UINT64_C(437461390639262508), UINT64_C(903684466786629599)
              },
              {
                /*204*/ UINT64_C(4039317927253320330), UINT64_C(722947573429303679)
              },
              {
                /*205*/ UINT64_C(6920803156544566587), UINT64_C(578358058743442943)
              },
              {
                /*206*/ UINT64_C(7383936235729396216), UINT64_C(925372893989508709)
              },
              {
                /*207*/ UINT64_C(9596497803325427296), UINT64_C(740298315191606967)
              },
              {
                /*208*/ UINT64_C(298500613176521190), UINT64_C(592238652153285574)
              },
              {
                /*209*/ UINT64_C(7856298610566254551), UINT64_C(947581843445256918)
              },
              {
                /*210*/ UINT64_C(13663736517936824287), UINT64_C(758065474756205534)
              },
              {
                /*211*/ UINT64_C(14620338029091369753), UINT64_C(606452379804964427)
              },
              {
                /*212*/ UINT64_C(8635145587578550312), UINT64_C(970323807687943084)
              },
              {
                /*213*/ UINT64_C(10597465284804750573), UINT64_C(776259046150354467)
              },
              {
                /*214*/ UINT64_C(1099274598359979812), UINT64_C(621007236920283574)
              },
              {
                /*215*/ UINT64_C(9137536986859788346), UINT64_C(993611579072453718)
              },
              {
                /*216*/ UINT64_C(14688727218971651323), UINT64_C(794889263257962974)
              },
              {
                /*217*/ UINT64_C(15440330589919231381), UINT64_C(635911410606370379)
              },
              {
                /*218*/ UINT64_C(13636482499645039241), UINT64_C(1017458256970192607)
              },
              {
                /*219*/ UINT64_C(3530488370232210746), UINT64_C(813966605576154086)
              },
              {
                /*220*/ UINT64_C(17581785955153409890), UINT64_C(651173284460923268)
              },
              {
                /*221*/ UINT64_C(5994764639793993884), UINT64_C(1041877255137477230)
              },
              {
                /*222*/ UINT64_C(4795811711835195107), UINT64_C(833501804109981784)
              },
              {
                /*223*/ UINT64_C(7525998184210066409), UINT64_C(666801443287985427)
              },
              {
                /*224*/ UINT64_C(15730945909478016578), UINT64_C(1066882309260776683)
              },
              {
                /*225*/ UINT64_C(1516710283356682293), UINT64_C(853505847408621347)
              },
              {
                /*226*/ UINT64_C(12281414670911076804), UINT64_C(682804677926897077)
              },
              {
                /*227*/ UINT64_C(4892868214490081593), UINT64_C(1092487484683035324)
              },
              {
                /*228*/ UINT64_C(7603643386333975598), UINT64_C(873989987746428259)
              },
              {
                /*229*/ UINT64_C(9772263523809090801), UINT64_C(699191990197142607)
              },
              {
                /*230*/ UINT64_C(878226379126903990), UINT64_C(1118707184315428172)
              },
              {
                /*231*/ UINT64_C(11770627547527254161), UINT64_C(894965747452342537)
              },
              {
                /*232*/ UINT64_C(2037804408537982682), UINT64_C(715972597961874030)
              },
              {
                /*233*/ UINT64_C(3260487053660772292), UINT64_C(1145556156738998448)
              },
              {
                /*234*/ UINT64_C(9987087272412438480), UINT64_C(916444925391198758)
              },
              {
                /*235*/ UINT64_C(15368367447413771430), UINT64_C(733155940312959006)
              },
              {
                /*236*/ UINT64_C(8605345143189106821), UINT64_C(586524752250367205)
              },
              {
                /*237*/ UINT64_C(13768552229102570914), UINT64_C(938439603600587528)
              },
              {
                /*238*/ UINT64_C(18393539412765877377), UINT64_C(750751682880470022)
              },
              {
                /*239*/ UINT64_C(7336133900728881255), UINT64_C(600601346304376018)
              },
              {
                /*240*/ UINT64_C(8048465426424299686), UINT64_C(960962154087001629)
              },
              {
                /*241*/ UINT64_C(10128121155881350072), UINT64_C(768769723269601303)
              },
              {
                /*242*/ UINT64_C(15481194554188900704), UINT64_C(615015778615681042)
              },
              {
                /*243*/ UINT64_C(10012516027734599833), UINT64_C(984025245785089668)
              },
              {
                /*244*/ UINT64_C(15388710451671500513), UINT64_C(787220196628071734)
              },
              {
                /*245*/ UINT64_C(16000317176079110734), UINT64_C(629776157302457387)
              },
              {
                /*246*/ UINT64_C(10843112222758935881), UINT64_C(1007641851683931820)
              },
              {
                /*247*/ UINT64_C(8674489778207148705), UINT64_C(806113481347145456)
              },
              {
                /*248*/ UINT64_C(3250243007823808641), UINT64_C(644890785077716365)
              },
              {
                /*249*/ UINT64_C(5200388812518093825), UINT64_C(1031825256124346184)
              },
              {
                /*250*/ UINT64_C(7849659864756385383), UINT64_C(825460204899476947)
              },
              {
                /*251*/ UINT64_C(17347774336030839276), UINT64_C(660368163919581557)
              },
              {
                /*252*/ UINT64_C(12999043678681701549), UINT64_C(1056589062271330492)
              },
              {
                /*253*/ UINT64_C(3020537313461540593), UINT64_C(845271249817064394)
              },
              {
                /*254*/ UINT64_C(6105778665511142797), UINT64_C(676216999853651515)
              },
              {
                /*255*/ UINT64_C(9769245864817828476), UINT64_C(1081947199765842424)
              },
              {
                /*256*/ UINT64_C(11504745506596173104), UINT64_C(865557759812673939)
              },
              {
                /*257*/ UINT64_C(12893145220018848806), UINT64_C(692446207850139151)
              },
              {
                /*258*/ UINT64_C(13250334722546337444), UINT64_C(1107913932560222642)
              },
              {
                /*259*/ UINT64_C(3221570148553249309), UINT64_C(886331146048178114)
              },
              {
                /*260*/ UINT64_C(6266604933584509770), UINT64_C(709064916838542491)
              },
              {
                /*261*/ UINT64_C(2647870264251394986), UINT64_C(1134503866941667986)
              },
              {
                /*262*/ UINT64_C(16875691470368757282), UINT64_C(907603093553334388)
              },
              {
                /*263*/ UINT64_C(2432506732069274856), UINT64_C(726082474842667511)
              },
              {
                /*264*/ UINT64_C(16703400644623061177), UINT64_C(580865979874134008)
              },
              {
                /*265*/ UINT64_C(4589348142945435944), UINT64_C(929385567798614414)
              },
              {
                /*266*/ UINT64_C(7360827329098259079), UINT64_C(743508454238891531)
              },
              {
                /*267*/ UINT64_C(2199313048536696940), UINT64_C(594806763391113225)
              },
              {
                /*268*/ UINT64_C(3518900877658715104), UINT64_C(951690821425781160)
              },
              {
                /*269*/ UINT64_C(2815120702126972083), UINT64_C(761352657140624928)
              },
              {
                /*270*/ UINT64_C(9630794191185398313), UINT64_C(609082125712499942)
              },
              {
                /*271*/ UINT64_C(651875446928996008), UINT64_C(974531401139999908)
              },
              {
                /*272*/ UINT64_C(7900197987027017452), UINT64_C(779625120911999926)
              },
              {
                /*273*/ UINT64_C(2630809574879703639), UINT64_C(623700096729599941)
              },
              {
                /*274*/ UINT64_C(15277341764033256792), UINT64_C(997920154767359905)
              },
              {
                /*275*/ UINT64_C(12221873411226605433), UINT64_C(798336123813887924)
              },
              {
                /*276*/ UINT64_C(13466847543723194670), UINT64_C(638668899051110339)
              },
              {
                /*277*/ UINT64_C(10478909625731380502), UINT64_C(1021870238481776543)
              },
              {
                /*278*/ UINT64_C(15761825330068925048), UINT64_C(817496190785421234)
              },
              {
                /*279*/ UINT64_C(16298809078797050362), UINT64_C(653996952628336987)
              },
              {
                /*280*/ UINT64_C(11320699267107639286), UINT64_C(1046395124205339180)
              },
              {
                /*281*/ UINT64_C(9056559413686111429), UINT64_C(837116099364271344)
              },
              {
                /*282*/ UINT64_C(10934596345690799466), UINT64_C(669692879491417075)
              },
              {
                /*283*/ UINT64_C(17495354153105279146), UINT64_C(1071508607186267320)
              },
              {
                /*284*/ UINT64_C(13996283322484223317), UINT64_C(857206885749013856)
              },
              {
                /*285*/ UINT64_C(7507677843245468330), UINT64_C(685765508599211085)
              },
              {
                /*286*/ UINT64_C(12012284549192749328), UINT64_C(1097224813758737736)
              },
              {
                /*287*/ UINT64_C(5920478824612289139), UINT64_C(877779851006990189)
              },
              {
                /*288*/ UINT64_C(8425731874431741635), UINT64_C(702223880805592151)
              },
              {
                /*289*/ UINT64_C(6102473369606965969), UINT64_C(1123558209288947442)
              },
              {
                /*290*/ UINT64_C(15950025139911303745), UINT64_C(898846567431157953)
              }
            };
            return &data[index][0];
          }
        };

        template<>
        struct cache_values<float> {
          constexpr static const int b0 = 59;
          constexpr static const int b1 = 61;

          static const uint64_t *less_than(int index) {
            static const uint64_t data[48] = {
              /*  0*/ UINT64_C(2305843009213693952), /*  1*/ UINT64_C(1441151880758558720),
              /*  2*/ UINT64_C(1801439850948198400), /*  3*/ UINT64_C(2251799813685248000),
              /*  4*/ UINT64_C(1407374883553280000), /*  5*/ UINT64_C(1759218604441600000),
              /*  6*/ UINT64_C(2199023255552000000), /*  7*/ UINT64_C(1374389534720000000),
              /*  8*/ UINT64_C(1717986918400000000), /*  9*/ UINT64_C(2147483648000000000),
              /* 10*/ UINT64_C(1342177280000000000), /* 11*/ UINT64_C(1677721600000000000),
              /* 12*/ UINT64_C(2097152000000000000), /* 13*/ UINT64_C(1310720000000000000),
              /* 14*/ UINT64_C(1638400000000000000), /* 15*/ UINT64_C(2048000000000000000),
              /* 16*/ UINT64_C(1280000000000000000), /* 17*/ UINT64_C(1600000000000000000),
              /* 18*/ UINT64_C(2000000000000000000), /* 19*/ UINT64_C(1250000000000000000),
              /* 20*/ UINT64_C(1562500000000000000), /* 21*/ UINT64_C(1953125000000000000),
              /* 22*/ UINT64_C(1220703125000000000), /* 23*/ UINT64_C(1525878906250000000),
              /* 24*/ UINT64_C(1907348632812500000), /* 25*/ UINT64_C(1192092895507812500),
              /* 26*/ UINT64_C(1490116119384765625), /* 27*/ UINT64_C(1862645149230957031),
              /* 28*/ UINT64_C(1164153218269348144), /* 29*/ UINT64_C(1455191522836685180),
              /* 30*/ UINT64_C(1818989403545856475), /* 31*/ UINT64_C(2273736754432320594),
              /* 32*/ UINT64_C(1421085471520200371), /* 33*/ UINT64_C(1776356839400250464),
              /* 34*/ UINT64_C(2220446049250313080), /* 35*/ UINT64_C(1387778780781445675),
              /* 36*/ UINT64_C(1734723475976807094), /* 37*/ UINT64_C(2168404344971008868),
              /* 38*/ UINT64_C(1355252715606880542), /* 39*/ UINT64_C(1694065894508600678),
              /* 40*/ UINT64_C(2117582368135750847), /* 41*/ UINT64_C(1323488980084844279),
              /* 42*/ UINT64_C(1654361225106055349), /* 43*/ UINT64_C(2067951531382569187),
              /* 44*/ UINT64_C(1292469707114105741), /* 45*/ UINT64_C(1615587133892632177),
              /* 46*/ UINT64_C(2019483917365790221), /* 47*/ UINT64_C(1262177448353618888)
            };
            return &data[index];
          }

          static const uint64_t *greater_than_equals(int index) {
            static const uint64_t data[30] = {
              /*  0*/ UINT64_C(576460752303423488), /*  1*/ UINT64_C(461168601842738790),
              /*  2*/ UINT64_C(368934881474191032), /*  3*/ UINT64_C(295147905179352825),
              /*  4*/ UINT64_C(472236648286964521), /*  5*/ UINT64_C(377789318629571617),
              /*  6*/ UINT64_C(302231454903657293), /*  7*/ UINT64_C(483570327845851669),
              /*  8*/ UINT64_C(386856262276681335), /*  9*/ UINT64_C(309485009821345068),
              /* 10*/ UINT64_C(495176015714152109), /* 11*/ UINT64_C(396140812571321687),
              /* 12*/ UINT64_C(316912650057057350), /* 13*/ UINT64_C(507060240091291760),
              /* 14*/ UINT64_C(405648192073033408), /* 15*/ UINT64_C(324518553658426726),
              /* 16*/ UINT64_C(519229685853482762), /* 17*/ UINT64_C(415383748682786210),
              /* 18*/ UINT64_C(332306998946228968), /* 19*/ UINT64_C(531691198313966349),
              /* 20*/ UINT64_C(425352958651173079), /* 21*/ UINT64_C(340282366920938463),
              /* 22*/ UINT64_C(544451787073501541), /* 23*/ UINT64_C(435561429658801233),
              /* 24*/ UINT64_C(348449143727040986), /* 25*/ UINT64_C(557518629963265578),
              /* 26*/ UINT64_C(446014903970612462), /* 27*/ UINT64_C(356811923176489970),
              /* 28*/ UINT64_C(570899077082383952), /* 29*/ UINT64_C(456719261665907161)
            };
            return &data[index];
          }
        };

        constexpr static const double log_10_2 = 0.30102999566398114;
        constexpr static const double log_10_5 = 0.6989700043360189;
        constexpr static const double log_2_5 = 2.321928094887362;

        template<typename T>
        inline void normalize(int &exp, uint64_t &mentissa) {
          if (exp) {
            mentissa += uint64_t(1) << float_info<T>::mentissa_width();
            exp = exp - float_info<T>::bias() - float_info<T>::mentissa_width();
          } else {
            exp = 1 - float_info<T>::bias() - float_info<T>::mentissa_width();
          }
        }

        inline void compute_shortest(uint64_t a, uint64_t b, uint64_t c, bool accept_smaller, bool accept_larger,
                                     bool break_tie_down, int &exponent_adjuster, uint64_t &shortest_base10) {
          int i = 0;
          if (!accept_larger)
            c -= 1;

          bool all_a_zero = true;
          bool all_b_zero = true;
          uint64_t a_next = a / 10;
          uint32_t a_remainder = a % 10;
          uint64_t b_next = b / 10;
          uint32_t b_remainder = b % 10;
          uint64_t c_next = c / 10;
          while (a_next < c_next) {
            a_remainder = a % 10;
            b_remainder = b % 10;

            all_b_zero &= bool(!b_remainder);
            all_a_zero &= bool(!a_remainder);

            a = a_next;
            b = b_next;
            c = c_next;
            a_next = a / 10;
            b_next = b / 10;
            c_next = c / 10;
            i++;
          }
          if (accept_smaller && all_a_zero && a % 10 == 0) {
            while (!(a_next % 10)) {
              b_remainder = b % 10;

              all_b_zero &= bool(!b_remainder);

              a = a_next;
              b = b_next;
              c = c_next;
              a_next = a / 10;
              b_next = b / 10;
              c_next = c / 10;
              i++;
            }
          }
          exponent_adjuster = i;

          bool is_tie = b_remainder == 5 && all_b_zero;
          bool want_to_round_down = b_remainder < 5 || (is_tie && break_tie_down);
          bool round_down = (want_to_round_down && (a != b || all_a_zero)) || (b + 1 > c);
          if (round_down) {
            shortest_base10 = b;
          } else {
            shortest_base10 = b + 1;
          }
        }

        template<typename T>
        inline uint64_t multiply_and_shift(uint64_t a, const uint64_t *b, int shift_right, bool round_up) {
          (void) a;
          (void) b;
          (void) shift_right;
          (void) round_up;
          return 0;
        }

        template<>
        inline uint64_t multiply_and_shift<double>(uint64_t a, const uint64_t *b, int shift_right, bool round_up) {
          uint64_t a0, a1, b0, b1, b2, b3, a0b0, a0b1, a0b2, a0b3, a1b0, a1b1, a1b2, a1b3;
          a0 = low(a);
          a1 = high(a);
          b0 = low(b[0]);
          b1 = high(b[0]);
          b2 = low(b[1]);
          b3 = high(b[1]);

          a0b0 = a0 * b0;
          a0b1 = a0 * b1;
          a0b2 = a0 * b2;
          a0b3 = a0 * b3;
          a1b0 = a1 * b0;
          a1b1 = a1 * b1;
          a1b2 = a1 * b2;
          a1b3 = a1 * b3;

          uint64_t result[6];
          result[0] = low(a0b0);
          result[1] = low(a0b1) + low(a1b0) + high(a0b0);
          result[2] = low(a0b2) + low(a1b1) + high(a0b1) + high(a1b0);
          result[3] = low(a0b3) + low(a1b2) + high(a0b2) + high(a1b1);
          result[4] = a1b3 + high(a0b3) + high(a1b2);

          result[1] += high(result[0]);
          result[2] += high(result[1]);
          result[3] += high(result[2]);
          result[4] += high(result[3]);
          result[5] = high(result[4]);

          uint64_t ret[4];
          ret[0] = low(result[0]) | ((low(result[1]) << 32) + high(result[0]));
          ret[1] = low(result[2]) | (low(result[3]) << 32);
          ret[2] = low(result[4]) | (low(result[5]) << 32);

          int index = shift_right / 64;
          int shift_right_in_index = shift_right - (index * 64);
          if (round_up) {
            if (shift_right_in_index) {
              if (!(ret[index] & (uint64_t(1) << (shift_right_in_index - 1))))
                round_up = false;
            } else {
              if (!(index > 0 && ret[index] & uint64_t(1) << 63))
                round_up = false;
            }
          }
          ret[index] >>= shift_right_in_index;
          ret[index] |= (ret[index + 1] & ((uint64_t(1) << shift_right_in_index) - 1)) << (64 - shift_right_in_index);
          ret[index] += round_up;
          return ret[index];
        }

        template<>
        inline uint64_t multiply_and_shift<float>(uint64_t a, const uint64_t *b, int shift_right, bool round_up) {
          uint64_t a0, a1, b0, b1, a0b0, a0b1, a1b0, a1b1;
          a0 = low(a);
          a1 = high(a);
          b0 = low(*b);
          b1 = high(*b);

          a0b0 = a0 * b0;
          a0b1 = a0 * b1;
          a1b0 = a1 * b0;
          a1b1 = a1 * b1;

          uint64_t result[4] = {};
          result[0] = low(a0b0);
          result[1] = low(a0b1) + low(a1b0) + high(a0b0);
          result[2] = low(a1b1) + high(a0b1) + high(a1b0);
          result[3] = high(a1b1);

          result[1] += high(result[0]);
          result[2] += high(result[1]);
          result[3] += high(result[2]);

          uint64_t ret[4];
          ret[0] = low(result[0]) | ((low(result[1]) << 32) + high(result[0]));
          ret[1] = low(result[2]) | (low(result[3]) << 32);

          int index = shift_right / 64;
          int shift_right_in_index = shift_right - (index * 64);
          if (round_up) {
            if (shift_right_in_index) {
              if (!(ret[index] & (uint64_t(1) << (shift_right_in_index - 1))))
                round_up = false;
            } else {
              if (!(index > 0 && ret[index] & uint64_t(1) << 63))
                round_up = false;
            }
          }
          ret[index] >>= shift_right_in_index;
          ret[index] |= (ret[index + 1] & ((uint64_t(1) << shift_right_in_index) - 1)) << (64 - shift_right_in_index);
          ret[index] += round_up;
          return ret[index];
        }

        inline uint64_t pow_int(int n, int exp) {
          if (!exp)
            return 1;
          uint64_t ret = uint64_t(n);
          for (int i = 0; i < exp; i++) {
            ret *= ret;
          }
          return ret;
        }

        template<typename T, typename SignificandType>
        static float_base10<SignificandType> decode(T f) {
          bool negative;
          int exp;
          uint64_t mentissa;
          get_parts(f, negative, exp, mentissa);
          bool shift_u_with_one = mentissa == 0 && exp > 1;

          if (is_nan(f)) {
            return {negative, false, true, 0, 0, 0};
          }
          if (is_inf(f)) {
            return {negative, true, false, 0, 0, 0};
          }
          if (!exp && !mentissa) {
            return {negative, false, false, 1, 0, 0};
          }

          bool accept_larger = (mentissa % 2 == 0);
          bool accept_smaller = accept_larger;

          normalize<T>(exp, mentissa);

          exp -= 2;
          mentissa *= 4;

          uint64_t u = mentissa;
          if (shift_u_with_one)
            u -= 1;
          else
            u -= 2;

          uint64_t w = mentissa + 2;

          int e10 = exp < 0 ? exp : 0;

          int q;
          int shift_right;
          bool zero[3] = {};
          if (exp >= 0) {
            q = max(0, int(exp * log_10_2) - 1);
            int k = cache_values<T>::b0 + int(q * log_2_5);
            shift_right = -exp + q + k;
            if (q - 1 <= float_info<T>::max_double_5_pow_q()) {
              uint64_t mod = pow_int(5, q - 1);
              if (mod) {
                zero[1] = (mentissa % mod) == 0;
              }
              if (q <= float_info<T>::max_double_5_pow_q()) {
                mod = pow_int(5, q);
                zero[0] = (u % mod) == 0;
                zero[2] = (w % mod) == 0;
              }
            }
          } else {
            q = max(0, int(-exp * log_10_5) - 1);
            int k = int(std::ceil((double(-exp) - double(q)) * log_2_5)) - cache_values<T>::b1;
            shift_right = q - k;
            if (q && q - 1 <= float_info<T>::max_double_2_pow_q()) {
              uint64_t mod = uint64_t(1) << int(q - 1);
              zero[1] = (mentissa % mod) == 0;

              if (q <= float_info<T>::max_double_2_pow_q()) {
                mod <<= 1;
                if (mod) {
                  zero[0] = (u % mod) == 0;
                  zero[2] = (w % mod) == 0;
                }
              }
            }
          }
          auto cache_value = exp >= 0 ? cache_values<T>::greater_than_equals(q) : cache_values<T>::less_than(-exp - q);
          uint64_t a = multiply_and_shift<T>(u, cache_value, shift_right, true);
          uint64_t b = multiply_and_shift<T>(mentissa, cache_value, shift_right, false);
          uint64_t c = multiply_and_shift<T>(w, cache_value, shift_right, false);

          int exponent_adjust;
          uint64_t shortest_base10;
          compute_shortest(a, b, c, accept_smaller && zero[0], accept_larger || !zero[2], zero[1], exponent_adjust,
                           shortest_base10);
          int significand_digit_count = count_chars(shortest_base10);
          int e = exponent_adjust + e10 + q;
          return {negative, false, false, uint8_t(significand_digit_count), e, shortest_base10};
        }

        template<typename T>
        inline int convert_parsed_to_buffer(const float_base10<T> &result, char *buffer, int buffer_size,
                                            int max_expanded_length, int *digits_truncated = nullptr) {
          if (buffer_size < 1)
            return 0;
          int offset = 0;
          if (result.nan) {
            if (buffer_size >= 3) {
              buffer[offset++] = 'n';
              buffer[offset++] = 'a';
              buffer[offset++] = 'n';
            }
            return offset;
          }

          if (result.negative) {
            buffer[offset++] = '-';
            buffer_size--;
          }

          if (result.inf) {
            if (buffer_size >= 3) {
              buffer[offset++] = 'i';
              buffer[offset++] = 'n';
              buffer[offset++] = 'f';
            }
            return offset;
          }

          char significan_buffer[17] = {};
          assert(result.significand_digit_count <= uint8_t(17));
          int digits_before_decimals = result.significand_digit_count + result.exp;
          int digits_after_decimals = result.exp<0 ? -result.exp : 0;
          int complete_digits = max(1, digits_before_decimals) + max(1, digits_after_decimals) + 1;
          if (complete_digits < max_expanded_length) {
            char *target_buffer = buffer + offset;
            uint64_t significand = result.significand;
            bool print_desimal_seperator = true;
            if (buffer_size < complete_digits) {
              int to_remove = complete_digits - buffer_size;
              if (digits_truncated)
                *digits_truncated = to_remove;

              int to_remove_after_decimals = std::min(to_remove, digits_after_decimals);
              for (int i = 0; i < to_remove_after_decimals; i++) {
                complete_digits--;
                digits_after_decimals--;
                significand /= 10;
              }
              to_remove -= to_remove_after_decimals;
              if (to_remove > 0) {
                print_desimal_seperator = false;
                if (!digits_after_decimals) {
                  complete_digits--;
                  to_remove--;
                }
                complete_digits--;
                to_remove--;
                if (to_remove > 0) {
                  int to_remove_before_decimals = std::min(to_remove, digits_before_decimals);
                  for (int i = 0; i < to_remove_before_decimals; i++) {
                    complete_digits--;
                    digits_before_decimals--;
                    significand /= 10;
                  }
                }
              } else if (to_remove == 0 && digits_after_decimals == 0) {
                print_desimal_seperator = false;
                complete_digits--;
              }
            }
            int index_pos = std::max(complete_digits - 1, 0);
            for (int i = 0; i < digits_after_decimals; i++, index_pos--) {
              char remainder = char(significand % 10);
              significand /= 10;
              target_buffer[index_pos] = '0' + remainder;
            }
            if (print_desimal_seperator) {
              if (digits_after_decimals == 0) {
                target_buffer[index_pos--] = '0';
              }
              target_buffer[index_pos--] = '.';
            }
            int add_zeros_before_decimal = std::max(result.exp, 0);
            for (int i = 0; i < add_zeros_before_decimal; i++, index_pos--) {
              target_buffer[index_pos] = '0';
              digits_before_decimals--;
            }
            for (int i = 0; i < digits_before_decimals; i++, index_pos--) {
              char remainder = char(significand % 10);
              significand /= 10;
              target_buffer[index_pos] = '0' + remainder;
            }
            if (digits_before_decimals <= 0)
              target_buffer[index_pos] = '0';
            return complete_digits + offset;
          } else {
            uint64_t significand = result.significand;
            int exp = result.exp;
            for (int i = 0; i < result.significand_digit_count; i++) {
              significan_buffer[result.significand_digit_count - i - 1] = '0' + significand % 10;
              significand /= 10;
            }

            exp += result.significand_digit_count;
            exp--;
            char exponent_buffer[4] = {};
            int exponent_digit_count = count_chars(exp);
            if (exp < 0) {
              exponent_buffer[0] = '-';
            }
            int abs_exp = std::abs(exp);
            for (int i = 0; i < exponent_digit_count; i++) {
              exponent_buffer[exponent_digit_count + (exp < 0) - i - 1] = '0' + abs_exp % 10;
              abs_exp /= 10;
            }
            exponent_digit_count += exp < 0;

            if (offset < buffer_size)
              buffer[offset++] = significan_buffer[0];
            else
              return offset;

            if (result.significand_digit_count > 1) {
              if (offset < buffer_size)
                buffer[offset++] = '.';
              else
                return offset;
            }
            int to_copy = min(buffer_size - offset, int(result.significand_digit_count) - 1);
            for (int i = 0; i < to_copy; i++) {
              buffer[offset++] = significan_buffer[1 + i];
            }

            if (offset >= buffer_size)
              return offset;

            buffer[offset++] = 'e';

            to_copy = min(buffer_size - offset, exponent_digit_count);
            for (int i = 0; i < to_copy; i++) {
              buffer[offset++] = exponent_buffer[i];
            }
          }

          return offset;
        }
      } // namespace ryu

      template<typename T>
      struct set_end_ptr {
        set_end_ptr(parsed_string<T> &parsedString, const char *&current)
          : parsedString(parsedString)
            , current(current) {
        }

        ~set_end_ptr() {
          parsedString.endptr = current;
        }

        parsed_string<T> &parsedString;
        const char *&current;
      };

      inline bool is_space(char a) {
        if (a == 0x20 || a == 0x09 || a == 0x0a || a == 0x0b || a == 0x0c || a == 0x0d)
          return true;
        return false;
      }

      template<typename T, bool NoDigitCount>
      inline parse_string_error parseNumber(const char *number, size_t size, parsed_string<T> &parsedString) {
        const char *current;
        set_end_ptr<T> setendptr(parsedString, current);
        int desimal_position = -1;
        bool increase_significand = true;

        parsedString.negative = false;
        parsedString.inf = 0;
        parsedString.nan = 0;
        parsedString.significand_digit_count = 0;
        parsedString.significand = 0;
        parsedString.exp = 0;

        const char *number_end = number + size;
        current = find_if(number, number_end, [](const char a) { return !is_space(a); });
        if (number_end == current) {
          return parse_string_error::empty_string;
        }
        if (*current == '-') {
          parsedString.negative = true;
          current++;
        }
        while (current < number_end) {
          if ((*current < '0' || *current > '9') && *current != '.')
            break;

          if (*current == '.') {
            if (desimal_position >= 0)
              return parse_string_error::multiple_commas;
            desimal_position = parsedString.significand_digit_count;
          } else {
#ifdef _MSC_VER
            bool localDigitCount = NoDigitCount;
            if (localDigitCount || parsedString.significand_digit_count < 19)
#else
      if (NoDigitCount || parsedString.significand_digit_count < 19)
#endif
            {
              parsedString.significand = parsedString.significand * T(10) + T(int(*current) - '0');
              parsedString.significand_digit_count++;
            } else if (increase_significand && parsedString.significand_digit_count < 20) {
              increase_significand = false;
              uint64_t digit = uint64_t(*current) - '0';
              static_assert(NoDigitCount || std::is_same<T, uint64_t>::value,
                            "When NoDigitCount is used the significand type has to be uint64_t");
              auto biggest_multiplier = (std::numeric_limits<uint64_t>::max() - digit) / parsedString.significand;

              if (biggest_multiplier >= 10) {
                parsedString.significand = parsedString.significand * T(10) + T(digit);
                parsedString.significand_digit_count++;
              }
            }
          }
          current++;
        }
        if (*current != 'e' && *current != 'E') {
          if (desimal_position >= 0)
            parsedString.exp = desimal_position - parsedString.significand_digit_count;
          else
            parsedString.exp = 0;
          return parse_string_error::ok;
        }
        current++;
        if (current == number_end) {
          return parse_string_error::illegal_exponent_value;
        }
        bool exponent_nagative = false;
        if (*current == '-') {
          exponent_nagative = true;
          current++;
        } else if (*current == '+') {
          current++;
        }
        if (current == number_end) {
          return parse_string_error::illegal_exponent_value;
        }
        int exponent = 0;
        bool exponent_assigned = false;
        while (current < number_end) {
          if ((*current < '0' || *current > '9'))
            break;
          exponent_assigned = true;
          exponent = exponent * 10 + (*current - '0');
          current++;
        }
        if (!exponent_assigned) {
          return parse_string_error::illegal_exponent_value;
        }

        if (exponent_nagative)
          exponent = -exponent;

        if (desimal_position >= 0)
          parsedString.exp = desimal_position - parsedString.significand_digit_count + exponent;
        else
          parsedString.exp = exponent;
        return parse_string_error::ok;
      }

      inline uint64_t getPow10(uint32_t pow) {
        static uint64_t data[] = {
          UINT64_C(1),
          UINT64_C(10),
          UINT64_C(100),
          UINT64_C(1000),
          UINT64_C(10000),
          UINT64_C(100000),
          UINT64_C(1000000),
          UINT64_C(10000000),
          UINT64_C(100000000),
          UINT64_C(1000000000),
          UINT64_C(10000000000),
          UINT64_C(100000000000),
          UINT64_C(1000000000000),
          UINT64_C(10000000000000),
          UINT64_C(100000000000000),
          UINT64_C(1000000000000000),
          UINT64_C(10000000000000000),
          UINT64_C(100000000000000000),
          UINT64_C(1000000000000000000),
          UINT64_C(10000000000000000000)
        };
        return data[pow];
      }

      template<typename T, typename SignificandType>
      inline T convertToNumber(const parsed_string<SignificandType> &parsed) {
        int base10exponent = parsed.exp + parsed.significand_digit_count - 1;
        if (base10exponent > float_info<T>::max_base10_exponent()) {
          return make_inf<T>(parsed.negative);
        } else if (base10exponent < float_info<T>::min_base10_exponent()) {
          return make_zero<T>(parsed.negative);
        }
        if (parsed.significand == 0) {
          return make_zero<T>(parsed.negative);
        }

#if 1
        if (parsed.significand < ((uint64_t(1) << 53)) && iabs<int>(parsed.exp) < count_chars((uint64_t(1) << 53))) {
          double ds(double(parsed.significand));
          double de(double(getPow10(iabs<int>(parsed.exp))));
          if (parsed.negative)
            ds = -ds;
          return parsed.exp<0 ? T(ds / de) : T(ds * de);
        }
#endif

        using uint_conversion_type = typename float_info<T>::str_to_float_conversion_type;
        uint_conversion_type a;
        uint_conversion_type b;
        assign_significand_to_float_conversion_type(parsed, a);
        int desimal_exponent = parsed.exp;
        auto binary_exponent = float_info<T>::str_to_float_binary_exponent_init();
        for (; desimal_exponent > 0; desimal_exponent--) {
          left_shift(a);
          copy_conversion_type(a, b);
          left_shift<2>(b);
          add(b, a);

          while (float_info<T>::conversion_type_has_mask(a)) {
            right_shift(a);
            binary_exponent++;
          }
        }

        for (; desimal_exponent < 0; desimal_exponent++) {
          binary_exponent -= float_info<T>::shift_left_msb_to_index(
            a, float_info<T>::str_to_float_binary_exponent_init());

          divide_by_10(a);
        }

        binary_exponent -= float_info<
          T>::shift_left_msb_to_index(a, float_info<T>::str_to_float_binary_exponent_init());

        binary_exponent += float_info<T>::bias();
        T to_digit;
        if (binary_exponent <= 0) {
          float_info<T>::copy_denormal_to_type(a, binary_exponent, parsed.negative, to_digit);
        } else if (binary_exponent < (int(1) << float_info<T>::exponent_width()) - 1) {
          float_info<T>::copy_normal_to_type(a, binary_exponent, parsed.negative, to_digit);
        } else {
          to_digit = make_inf<T>(parsed.negative);
        }
        return to_digit;
      }

      namespace ryu {
        template<typename T>
        int to_buffer(T d, char *buffer, int buffer_size, int *digits_truncated = nullptr) {
          auto decoded = decode<T, uint64_t>(d);
          return convert_parsed_to_buffer(decoded, buffer, buffer_size, float_info<T>::str_to_float_expanded_length(),
                                          digits_truncated);
        }

        template<typename T>
        inline std::string to_string(T f) {
          auto decoded = decode<T, uint64_t>(f);
          std::string ret;
          ret.resize(25);
          ret.resize(
            size_t(convert_parsed_to_buffer(decoded, &ret[0], int(ret.size()),
                                            float_info<T>::str_to_float_expanded_length())));
          return ret;
        }
      } // namespace ryu

      namespace integer {
        template<typename T>
        inline int to_buffer(T integer, char *buffer, int buffer_size, int *digits_truncated = nullptr) {
          static_assert(std::is_integral<T>::value, "Tryint to convert non int to string");
          int chars_to_write = ft::count_chars(integer);
          char *target_buffer = buffer;
          bool negative = false;
          if (std::is_signed<T>::value) {
            if (integer < 0) {
              target_buffer[0] = '-';
              target_buffer++;
              buffer_size--;
              negative = true;
            }
          }
          int to_remove = chars_to_write - buffer_size;
          if (to_remove > 0) {
            for (int i = 0; i < to_remove; i++) {
              integer /= 10;
            }
            if (digits_truncated)
              *digits_truncated = to_remove;
            chars_to_write -= to_remove;
          } else if (digits_truncated)
            *digits_truncated = 0;

          for (int i = 0; i < chars_to_write; i++) {
            int remainder = integer % 10;
            if (std::is_signed<T>::value) {
              if (negative)
                remainder = -remainder;
            }
            integer /= 10;
            target_buffer[chars_to_write - 1 - i] = '0' + char(remainder);
          }

          return chars_to_write + negative;
        }

        template<typename T, typename SignificandType>
        inline typename std::enable_if<std::is_signed<T>::value, T>::type make_integer_return_value(
          SignificandType significand,
          bool negative) {
          return negative ? -T(significand) : T(significand);
        }

        template<typename T, typename SignificandType>
        inline typename std::enable_if<std::is_unsigned<T>::value, T>::type make_integer_return_value(
          SignificandType significand, bool) {
          return T(significand);
        }

        template<typename T, typename SignificandType>
        inline T convert_to_integer(const parsed_string<SignificandType> &parsed) {
          if (parsed.inf)
            return parsed.negative ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
          if (parsed.nan)
            return T(0);

          int exp = parsed.exp;
          auto significand = parsed.significand;
          if (exp < 0) {
            int chars_in_sig = count_chars(significand);
            if (-exp >= chars_in_sig)
              return T(0);
            while (exp < 0) {
              significand /= 10;
              exp++;
            }
          } else if (exp > 0) {
            int chars_in_sig = count_chars(significand);
            if (exp > ft::StaticLog10<T, std::numeric_limits<T>::max(), 0, 0, true>::get() - chars_in_sig)
              return parsed.negative ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
            while (exp > 0) {
              significand *= 10;
              exp--;
            }
          }
          return make_integer_return_value<T>(significand, bool(parsed.negative));
        }

        template<typename T>
        inline parse_string_error to_integer(const char *str, size_t size, T &target, const char *(&endptr)) {
          using SignificandType = typename std::make_unsigned<T>::type;
          parsed_string<SignificandType> ps;
          auto parseResult = parseNumber<SignificandType, true>(str, size, ps);
          endptr = ps.endptr;
          if (parseResult != parse_string_error::ok) {
            target = 0;
          } else {
            target = convert_to_integer<T>(ps);
          }
          return parseResult;
        }

        template<typename T>
        inline parse_string_error to_integer(const std::string &str, T &target, const char *(&endptr)) {
          return to_integer(str.c_str(), str.size(), target, endptr);
        }
      } // namespace integer

      template<typename T>
      inline parse_string_error to_ieee_t(const char *str, size_t size, T &target, const char *(&endptr)) {
        parsed_string<uint64_t> ps;
        auto parseResult = parseNumber<uint64_t, false>(str, size, ps);
        endptr = ps.endptr;
        if (parseResult != parse_string_error::ok) {
          target = make_nan<T>(true, 1);
        } else {
          target = convertToNumber<T>(ps);
        }
        return parseResult;
      }

      inline parse_string_error to_float(const char *str, size_t size, float &target, const char *(&endptr)) {
        return to_ieee_t(str, size, target, endptr);
      }

      inline parse_string_error to_double(const char *str, size_t size, double &target, const char *(&endptr)) {
        return to_ieee_t(str, size, target, endptr);
      }
    } // namespace ft
  } // namespace Internal
  /// \private
  template<>
  struct TypeHandler<double> {
    static inline Error to(double &to_type, ParseContext &context) {
      const char *pointer;
      auto result = Internal::ft::to_double(context.token.value.data, context.token.value.size, to_type, pointer);
      if (result != Internal::ft::parse_string_error::ok ||
          context.token.value.data + context.token.value.size != pointer)
        return Error::FailedToParseDouble;
      return Error::NoError;
    }

    static inline void from(const double &d, Token &token, Serializer &serializer) {
      // char buf[1/*'-'*/ + (DBL_MAX_10_EXP+1)/*308+1 digits*/ + 1/*'.'*/ + 6/*Default? precision*/ + 1/*\0*/];
      char buf[32];
      int size;
      size = Internal::ft::ryu::to_buffer(d, buf, sizeof(buf));

      if (size <= 0) {
        return;
      }

      token.value_type = Type::Number;
      token.value.data = buf;
      token.value.size = size_t(size);
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<float> {
    static inline Error to(float &to_type, ParseContext &context) {
      const char *pointer;
      auto result = Internal::ft::to_float(context.token.value.data, context.token.value.size, to_type, pointer);
      if (result != Internal::ft::parse_string_error::ok ||
          context.token.value.data + context.token.value.size != pointer)
        return Error::FailedToParseFloat;
      return Error::NoError;
    }

    static inline void from(const float &f, Token &token, Serializer &serializer) {
      char buf[16];
      int size;
      size = Internal::ft::ryu::to_buffer(f, buf, sizeof(buf));
      if (size < 0) {
        return;
      }

      token.value_type = Type::Number;
      token.value.data = buf;
      token.value.size = size_t(size);
      serializer.write(token);
    }
  };

  /// \private
  template<typename T>
  struct TypeHandlerIntType {
    static inline Error to(T &to_type, ParseContext &context) {
      const char *pointer;
      auto parse_error =
          Internal::ft::integer::to_integer(context.token.value.data, context.token.value.size, to_type, pointer);
      if (parse_error != Internal::ft::parse_string_error::ok || context.token.value.data == pointer)
        return Error::FailedToParseInt;
      return Error::NoError;
    }

    static inline void from(const T &from_type, Token &token, Serializer &serializer) {
      char buf[40];
      int digits_truncated;
      int size = Internal::ft::integer::to_buffer(from_type, buf, sizeof(buf), &digits_truncated);
      if (size <= 0 || digits_truncated) {
        fprintf(stderr, "error serializing int token\n");
        return;
      }

      token.value_type = Type::Number;
      token.value.data = buf;
      token.value.size = size_t(size);
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<short int> : TypeHandlerIntType<short int> {
  };

  /// \private
  template<>
  struct TypeHandler<unsigned short int> : TypeHandlerIntType<unsigned short int> {
  };

  /// \private
  template<>
  struct TypeHandler<int> : TypeHandlerIntType<int> {
  };

  /// \private
  template<>
  struct TypeHandler<unsigned int> : TypeHandlerIntType<unsigned int> {
  };

  /// \private
  template<>
  struct TypeHandler<long int> : TypeHandlerIntType<long int> {
  };

  /// \private
  template<>
  struct TypeHandler<unsigned long int> : TypeHandlerIntType<unsigned long int> {
  };

  /// \private
  template<>
  struct TypeHandler<long long int> : TypeHandlerIntType<long long int> {
  };

  /// \private
  template<>
  struct TypeHandler<unsigned long long int> : TypeHandlerIntType<unsigned long long int> {
  };

  template<>
  struct TypeHandler<uint8_t> : TypeHandlerIntType<uint8_t> {
  };

  template<>
  struct TypeHandler<int8_t> : TypeHandlerIntType<int8_t> {
  };

  template<>
  struct TypeHandler<char> : TypeHandlerIntType<char> {
  };

  /// \private
  template<typename T>
  struct TypeHandler<Nullable<T> > {
  public:
    static inline Error to(Nullable<T> &to_type, ParseContext &context) {
      if (context.token.value_type == Type::Null)
        return Error::NoError;
      return TypeHandler<T>::to(to_type.data, context);
    }

    static inline void from(const Nullable<T> &opt, Token &token, Serializer &serializer) {
      TypeHandler<T>::from(opt(), token, serializer);
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<NullableChecked<T> > {
  public:
    static inline Error to(NullableChecked<T> &to_type, ParseContext &context) {
      if (context.token.value_type == Type::Null) {
        to_type.null = true;
        return Error::NoError;
      }
      to_type.null = false;
      return TypeHandler<T>::to(to_type.data, context);
    }

    static inline void from(const NullableChecked<T> &opt, Token &token, Serializer &serializer) {
      if (opt.null) {
        const char nullChar[] = "null";
        token.value_type = Type::Null;
        token.value = DataRef(nullChar);
        serializer.write(token);
      } else {
        TypeHandler<T>::from(opt(), token, serializer);
      }
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<Optional<T> > {
  public:
    static inline Error to(Optional<T> &to_type, ParseContext &context) {
      return TypeHandler<T>::to(to_type.data, context);
    }

    static inline void from(const Optional<T> &opt, Token &token, Serializer &serializer) {
      TypeHandler<T>::from(opt(), token, serializer);
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<OptionalChecked<T> > {
  public:
    static inline Error to(OptionalChecked<T> &to_type, ParseContext &context) {
      to_type.assigned = true;
      return TypeHandler<T>::to(to_type.data, context);
    }

    static inline void from(const OptionalChecked<T> &opt, Token &token, Serializer &serializer) {
      if (opt.assigned)
        TypeHandler<T>::from(opt(), token, serializer);
    }
  };

#ifdef JS_STD_OPTIONAL
  /// \private
  template<typename T>
  struct TypeHandler<std::optional<T> > {
  public:
    static inline Error to(std::optional<T> &to_type, ParseContext &context) {
      to_type.emplace();
      return TypeHandler<T>::to(to_type.value(), context);
    }

    static inline void from(const std::optional<T> &opt, Token &token, Serializer &serializer) {
      if (opt.has_value())
        TypeHandler<T>::from(opt.value(), token, serializer);
    }
  };
#endif

  /// \private
  template<typename T>
  struct TypeHandler<std::shared_ptr<T> > {
  public:
    static inline Error to(std::shared_ptr<T> &to_type, ParseContext &context) {
      if (context.token.value_type != Type::Null) {
        if (!to_type)
          to_type = std::make_shared<T>();
        return TypeHandler<T>::to(*to_type.get(), context);
      }
      to_type.reset();
      return Error::NoError;
    }

    static inline void from(const std::shared_ptr<T> &unique, Token &token, Serializer &serializer) {
      if (unique) {
        TypeHandler<T>::from(*unique.get(), token, serializer);
      } else {
        const char nullChar[] = "null";
        token.value_type = Type::Null;
        token.value = DataRef(nullChar);
        serializer.write(token);
      }
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<std::unique_ptr<T> > {
  public:
    static inline Error to(std::unique_ptr<T> &to_type, ParseContext &context) {
      if (context.token.value_type != Type::Null) {
        if (!to_type)
          to_type.reset(new T());
        return TypeHandler<T>::to(*to_type.get(), context);
      }
      to_type.reset(nullptr);
      return Error::NoError;
    }

    static inline void from(const std::unique_ptr<T> &unique, Token &token, Serializer &serializer) {
      if (unique) {
        TypeHandler<T>::from(*unique.get(), token, serializer);
      } else {
        const char nullChar[] = "null";
        token.value_type = Type::Null;
        token.value = DataRef(nullChar);
        serializer.write(token);
      }
    }
  };

  /// \private
  template<>
  struct TypeHandler<bool> {
    static inline Error to(bool &to_type, ParseContext &context) {
      if (context.token.value.size == sizeof("true") - 1 &&
          memcmp("true", context.token.value.data, sizeof("true") - 1) == 0)
        to_type = true;
      else if (context.token.value.size == sizeof("false") - 1 &&
               memcmp("false", context.token.value.data, sizeof("false") - 1) == 0)
        to_type = false;
      else
        return Error::FailedToParseBoolean;

      return Error::NoError;
    }

    static inline void from(const bool &b, Token &token, Serializer &serializer) {
      const char trueChar[] = "true";
      const char falseChar[] = "false";
      token.value_type = Type::Bool;
      if (b) {
        token.value = DataRef(trueChar);
      } else {
        token.value = DataRef(falseChar);
      }
      serializer.write(token);
    }
  };

#ifdef JS_STD_TIMEPOINT
/// \private
namespace Internal
{
    template <class T, template <class...> class Template>
    struct is_specialization : std::false_type {};

    template <template <class...> class Template, class... Args>
    struct is_specialization<Template<Args...>, Template> : std::true_type {};
}

/// \private
template <class T>
struct TypeHandler<T, typename std::enable_if_t<Internal::is_specialization<T, std::chrono::time_point>::value>>
{
    static inline Error to(T& to_type, ParseContext &context)
    {
        uint64_t t;
        Error err = TypeHandler<uint64_t>::to(t, context);
        if (err != Error::NoError)
            return err;

        if (t <= 1e11) // Seconds => 10 digits, normally
            to_type = T{std::chrono::seconds{t}};
        else if (t <= 1e14) // Milliseconds => 13 digits, normally
            to_type = T{std::chrono::milliseconds{t}};
        else if (t <= 1e17) // Microseconds
            to_type = T{std::chrono::microseconds{t}};
        else if (t <= 1e20) // Nanoseconds
            if constexpr (std::is_same_v<std::chrono::high_resolution_clock::time_point, T>)
                to_type = T{std::chrono::nanoseconds{t}};
            else
                return JS::Error::IllegalDataValue;
        else
            return JS::Error::IllegalDataValue;

        return JS::Error::NoError;
    }

    static inline void from(const T& val, Token &token, Serializer &serializer)
    {
        uint64_t t;
        if constexpr (std::is_same_v<std::chrono::high_resolution_clock::time_point, T>)
        	t = std::chrono::duration_cast<std::chrono::nanoseconds>(val.time_since_epoch()).count();
		else
        	t = std::chrono::duration_cast<std::chrono::microseconds>(val.time_since_epoch()).count();
		while (t % 1000 == 0 && t > (uint64_t)1e10)
			t /= 1000;
        TypeHandler<uint64_t>::from(t, token, serializer);
    }
};
#endif

  /// \private
  template<typename T>
  struct TypeHandler<std::vector<T> > {
    static inline Error to(std::vector<T> &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;
      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      to_type.clear();
      to_type.reserve(10);
      while (context.token.value_type != JS::Type::ArrayEnd) {
        to_type.push_back(T());
        error = TypeHandler<T>::to(to_type.back(), context);
        if (error != JS::Error::NoError)
          break;
        error = context.nextToken();
        if (error != JS::Error::NoError)
          break;
      }

      return error;
    }

    static inline void from(const std::vector<T> &vec, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");

      for (auto &index: vec) {
        TypeHandler<T>::from(index, token, serializer);
      }

      token.name = DataRef("");

      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<std::vector<bool> > {
  public:
    static inline Error to(std::vector<bool> &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;
      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      to_type.clear();
      to_type.reserve(10);
      while (context.token.value_type != JS::Type::ArrayEnd) {
        bool toBool;
        error = TypeHandler<bool>::to(toBool, context);
        to_type.push_back(toBool);
        if (error != JS::Error::NoError)
          break;
        error = context.nextToken();
        if (error != JS::Error::NoError)
          break;
      }

      return error;
    }

    static inline void from(const std::vector<bool> &vec, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");

      for (bool index: vec) {
        TypeHandler<bool>::from(index, token, serializer);
      }

      token.name = DataRef("");

      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<SilentString> {
    static inline Error to(SilentString &to_type, ParseContext &context) {
      return TypeHandler<std::string>::to(to_type.data, context);
    }

    static inline void from(const SilentString &str, Token &token, Serializer &serializer) {
      if (str.data.size()) {
        TypeHandler<std::string>::from(str.data, token, serializer);
      }
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<SilentVector<T> > {
  public:
    static inline Error to(SilentVector<T> &to_type, ParseContext &context) {
      return TypeHandler<std::vector<T> >::to(to_type.data, context);
    }

    static inline void from(const SilentVector<T> &vec, Token &token, Serializer &serializer) {
      if (vec.data.size()) {
        TypeHandler<std::vector<T> >::from(vec.data, token, serializer);
      }
    }
  };

  /// \private
  template<typename T>
  struct TypeHandler<SilentUniquePtr<T> > {
  public:
    static inline Error to(SilentUniquePtr<T> &to_type, ParseContext &context) {
      return TypeHandler<std::unique_ptr<T> >::to(to_type.data, context);
    }

    static inline void from(const SilentUniquePtr<T> &ptr, Token &token, Serializer &serializer) {
      if (ptr.data) {
        TypeHandler<std::unique_ptr<T> >::from(ptr.data, token, serializer);
      }
    }
  };

  /// \private
  template<>
  struct TypeHandler<std::vector<Token> > {
  public:
    static inline Error to(std::vector<Token> &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart && context.token.value_type != JS::Type::ObjectStart) {
        to_type.push_back(context.token);
        return context.error;
      }
      to_type.clear();
      to_type.push_back(context.token);
      bool buffer_change = false;
      auto ref = context.tokenizer.registerNeedMoreDataCallback([&buffer_change](JS::Tokenizer &tokenizer) {
        JS_UNUSED(tokenizer);
        buffer_change = true;
      });

      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level && buffer_change == false) {
        error = context.nextToken();
        to_type.push_back(context.token);
        if (context.token.value_type == Type::ArrayStart || context.token.value_type == Type::ObjectStart)
          level++;
        else if (context.token.value_type == Type::ArrayEnd || context.token.value_type == Type::ObjectEnd)
          level--;
      }
      if (buffer_change)
        return Error::NonContigiousMemory;

      return error;
    }

    static inline void from(const std::vector<Token> &from_type, Token &token, Serializer &serializer) {
      for (auto &t: from_type) {
        token = t;
        serializer.write(token);
      }
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonTokens> {
  public:
    static inline Error to(JsonTokens &to_type, ParseContext &context) {
      return TypeHandler<std::vector<Token> >::to(to_type.data, context);
    }

    static inline void from(const JsonTokens &from, Token &token, Serializer &serializer) {
      return TypeHandler<std::vector<Token> >::from(from.data, token, serializer);
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonArrayRef> {
    static inline Error to(JsonArrayRef &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;

      bool buffer_change = false;
      auto ref = context.tokenizer.registerNeedMoreDataCallback([&buffer_change](JS::Tokenizer &tokenizer) {
        JS_UNUSED(tokenizer);
        buffer_change = true;
      });

      to_type.ref.data = context.token.value.data;

      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level && buffer_change == false) {
        error = context.nextToken();
        if (context.token.value_type == Type::ArrayStart)
          level++;
        else if (context.token.value_type == Type::ArrayEnd)
          level--;
      }
      if (buffer_change)
        return Error::NonContigiousMemory;

      to_type.ref.size = size_t(context.token.value.data + context.token.value.size - to_type.ref.data);

      return error;
    }

    static inline void from(const JsonArrayRef &from_type, Token &token, Serializer &serializer) {
      token.value = from_type.ref;
      token.value_type = Type::Verbatim;
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonArray> {
    static inline Error to(JsonArray &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;

      context.tokenizer.copyFromValue(context.token, to_type.data);

      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level) {
        error = context.nextToken();
        if (context.token.value_type == Type::ArrayStart)
          level++;
        else if (context.token.value_type == Type::ArrayEnd)
          level--;
      }

      if (error == JS::Error::NoError)
        context.tokenizer.copyIncludingValue(context.token, to_type.data);

      return error;
    }

    static inline void from(const JsonArray &from_type, Token &token, Serializer &serializer) {
      token.value_type = JS::Type::Verbatim; // Need to fool the serializer to just write value as verbatim

      if (from_type.data.empty()) {
        std::string emptyArray("[]");
        token.value = DataRef(emptyArray);
        serializer.write(token);
      } else {
        token.value = DataRef(from_type.data);
        serializer.write(token);
      }
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonObjectRef> {
    static inline Error to(JsonObjectRef &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ObjectStart)
        return Error::ExpectedObjectStart;

      bool buffer_change = false;
      auto ref = context.tokenizer.registerNeedMoreDataCallback([&buffer_change](JS::Tokenizer &tokenizer) {
        JS_UNUSED(tokenizer);
        buffer_change = true;
      });

      to_type.ref.data = context.token.value.data;
      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level && buffer_change == false) {
        error = context.nextToken();
        if (context.token.value_type == Type::ObjectStart)
          level++;
        else if (context.token.value_type == Type::ObjectEnd)
          level--;
      }
      if (buffer_change)
        return Error::NonContigiousMemory;

      to_type.ref.size = size_t(context.token.value.data + context.token.value.size - to_type.ref.data);
      return error;
    }

    static inline void from(const JsonObjectRef &from_type, Token &token, Serializer &serializer) {
      token.value = from_type.ref;
      token.value_type = Type::Verbatim;
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonObject> {
    static inline Error to(JsonObject &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ObjectStart)
        return Error::ExpectedObjectStart;

      context.tokenizer.copyFromValue(context.token, to_type.data);

      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level) {
        error = context.nextToken();
        if (context.token.value_type == Type::ObjectStart)
          level++;
        else if (context.token.value_type == Type::ObjectEnd)
          level--;
      }

      context.tokenizer.copyIncludingValue(context.token, to_type.data);

      return error;
    }

    static inline void from(const JsonObject &from_type, Token &token, Serializer &serializer) {
      token.value_type = JS::Type::Verbatim; // Need to fool the serializer to just write value as verbatim

      if (from_type.data.empty()) {
        std::string emptyObject("{}");
        token.value = DataRef(emptyObject);
        serializer.write(token);
      } else {
        token.value = DataRef(from_type.data);
        serializer.write(token);
      }
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonObjectOrArrayRef> {
    static inline Error to(JsonObjectOrArrayRef &to_type, ParseContext &context) {
      JS::Type openType;
      JS::Type closeType;
      if (context.token.value_type == JS::Type::ObjectStart) {
        openType = JS::Type::ObjectStart;
        closeType = JS::Type::ObjectEnd;
      } else if (context.token.value_type == JS::Type::ArrayStart) {
        openType = JS::Type::ArrayStart;
        closeType = JS::Type::ArrayEnd;
      } else {
        return Error::ExpectedObjectStart;
      }

      bool buffer_change = false;
      auto ref = context.tokenizer.registerNeedMoreDataCallback([&buffer_change](JS::Tokenizer &tokenizer) {
        JS_UNUSED(tokenizer);
        buffer_change = true;
      });

      to_type.ref.data = context.token.value.data;
      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level && buffer_change == false) {
        error = context.nextToken();
        if (context.token.value_type == openType)
          level++;
        else if (context.token.value_type == closeType)
          level--;
      }
      if (buffer_change)
        return Error::NonContigiousMemory;

      to_type.ref.size = size_t(context.token.value.data + context.token.value.size - to_type.ref.data);
      return error;
    }

    static inline void from(const JsonObjectOrArrayRef &from_type, Token &token, Serializer &serializer) {
      token.value = from_type.ref;
      token.value_type = Type::Verbatim;
      serializer.write(token);
    }
  };

  /// \private
  template<>
  struct TypeHandler<JsonObjectOrArray> {
    static inline Error to(JsonObjectOrArray &to_type, ParseContext &context) {
      JS::Type openType;
      JS::Type closeType;
      if (context.token.value_type == JS::Type::ObjectStart) {
        openType = JS::Type::ObjectStart;
        closeType = JS::Type::ObjectEnd;
      } else if (context.token.value_type == JS::Type::ArrayStart) {
        openType = JS::Type::ArrayStart;
        closeType = JS::Type::ArrayEnd;
      } else {
        return Error::ExpectedObjectStart;
      }

      context.tokenizer.copyFromValue(context.token, to_type.data);

      size_t level = 1;
      Error error = Error::NoError;
      while (error == JS::Error::NoError && level) {
        error = context.nextToken();
        if (context.token.value_type == openType)
          level++;
        else if (context.token.value_type == closeType)
          level--;
      }

      context.tokenizer.copyIncludingValue(context.token, to_type.data);

      return error;
    }

    static inline void from(const JsonObjectOrArray &from_type, Token &token, Serializer &serializer) {
      token.value_type = JS::Type::Verbatim; // Need to fool the serializer to just write value as verbatim

      if (from_type.data.empty()) {
        std::string emptyObjectOrArray("{}"); // Use object as default
        token.value = DataRef(emptyObjectOrArray);
        serializer.write(token);
      } else {
        token.value = DataRef(from_type.data);
        serializer.write(token);
      }
    }
  };

  namespace Internal {
    template<size_t INDEX, typename... Ts>
    struct TupleTypeHandler {
      static inline Error to(JS::Tuple<Ts...> &to_type, ParseContext &context) {
        using Type = typename JS::TypeAt<sizeof...(Ts) - INDEX, Ts...>::type;
        Error error = TypeHandler<Type>::to(to_type.template get<sizeof...(Ts) - INDEX>(), context);
        if (error != JS::Error::NoError)
          return error;
        error = context.nextToken();
        if (error != JS::Error::NoError)
          return error;
        return TupleTypeHandler<INDEX - 1, Ts...>::to(to_type, context);
      }

      static inline void from(const JS::Tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
        using Type = typename JS::TypeAt<sizeof...(Ts) - INDEX, Ts...>::type;
        TypeHandler<Type>::from(from_type.template get<sizeof...(Ts) - INDEX>(), token, serializer);
        TupleTypeHandler<INDEX - 1, Ts...>::from(from_type, token, serializer);
      }
    };

    /// \private
    template<typename... Ts>
    struct TupleTypeHandler<0, Ts...> {
      static inline Error to(JS::Tuple<Ts...>, ParseContext &context) {
        JS_UNUSED(context);
        return Error::NoError;
      }

      static inline void from(const JS::Tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
        JS_UNUSED(from_type);
        JS_UNUSED(token);
        JS_UNUSED(serializer);
      }
    };
  } // namespace Internal

  /// \private
  template<typename... Ts>
  struct TypeHandler<JS::Tuple<Ts...> > {
    static inline Error to(JS::Tuple<Ts...> &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;
      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      error = JS::Internal::TupleTypeHandler<sizeof...(Ts), Ts...>::to(to_type, context);
      if (error != JS::Error::NoError)
        return error;
      if (context.token.value_type != JS::Type::ArrayEnd)
        return Error::ExpectedArrayEnd;
      return Error::NoError;
    }

    static inline void from(const JS::Tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");

      JS::Internal::TupleTypeHandler<sizeof...(Ts), Ts...>::from(from_type, token, serializer);
      token.name = DataRef("");

      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  namespace Internal {
    template<size_t INDEX, typename... Ts>
    struct StdTupleTypeHandler {
      static inline Error to(std::tuple<Ts...> &to_type, ParseContext &context) {
        using Type = typename std::tuple_element<sizeof...(Ts) - INDEX, std::tuple<Ts...> >::type;
        Error error = TypeHandler<Type>::to(std::get<sizeof...(Ts) - INDEX>(to_type), context);
        if (error != JS::Error::NoError)
          return error;
        error = context.nextToken();
        if (error != JS::Error::NoError)
          return error;
        return StdTupleTypeHandler<INDEX - 1, Ts...>::to(to_type, context);
      }

      static inline void from(const std::tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
        using Type = typename std::tuple_element<sizeof...(Ts) - INDEX, std::tuple<Ts...> >::type;
        TypeHandler<Type>::from(std::get<sizeof...(Ts) - INDEX>(from_type), token, serializer);
        StdTupleTypeHandler<INDEX - 1, Ts...>::from(from_type, token, serializer);
      }
    };

    /// \private
    template<typename... Ts>
    struct StdTupleTypeHandler<0, Ts...> {
      static inline Error to(std::tuple<Ts...> &, ParseContext &context) {
        JS_UNUSED(context);
        return Error::NoError;
      }

      static inline void from(const std::tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
        JS_UNUSED(from_type);
        JS_UNUSED(token);
        JS_UNUSED(serializer);
      }
    };
  } // namespace Internal
  /// \private
  template<typename... Ts>
  struct TypeHandler<std::tuple<Ts...> > {
    static inline Error to(std::tuple<Ts...> &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;
      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      error = JS::Internal::StdTupleTypeHandler<sizeof...(Ts), Ts...>::to(to_type, context);
      if (error != JS::Error::NoError)
        return error;
      if (context.token.value_type != JS::Type::ArrayEnd)
        return Error::ExpectedArrayEnd;
      return Error::NoError;
    }

    static inline void from(const std::tuple<Ts...> &from_type, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");

      JS::Internal::StdTupleTypeHandler<sizeof...(Ts), Ts...>::from(from_type, token, serializer);
      token.name = DataRef("");

      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  template<typename T>
  struct OneOrMany {
    std::vector<T> data;
  };

  template<typename T>
  struct TypeHandler<OneOrMany<T> > {
  public:
    static inline Error to(OneOrMany<T> &to_type, ParseContext &context) {
      if (context.token.value_type == Type::ArrayStart) {
        context.error = TypeHandler<std::vector<T> >::to(to_type.data, context);
      } else {
        to_type.data.push_back(T());
        context.error = TypeHandler<T>::to(to_type.data.back(), context);
      }
      return context.error;
    }

    static void from(const OneOrMany<T> &from, Token &token, Serializer &serializer) {
      if (from.data.empty())
        return;
      if (from.data.size() > 1) {
        TypeHandler<std::vector<T> >::from(from.data, token, serializer);
      } else {
        TypeHandler<T>::from(from.data.front(), token, serializer);
      }
    }
  };

  template<typename T, size_t N>
  struct TypeHandler<T[N]> {
  public:
    static inline Error to(T (&to_type)[N], ParseContext &context) {
      if (context.token.value_type != Type::ArrayStart)
        return JS::Error::ExpectedArrayStart;

      context.nextToken();
      for (size_t i = 0; i < N; i++) {
        if (context.error != JS::Error::NoError)
          return context.error;
        context.error = TypeHandler<T>::to(to_type[i], context);
        if (context.error != JS::Error::NoError)
          return context.error;

        context.nextToken();
      }

      if (context.token.value_type != Type::ArrayEnd)
        return JS::Error::ExpectedArrayEnd;
      return context.error;
    }

    static void from(const T (&from)[N], Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");
      for (size_t i = 0; i < N; i++)
        TypeHandler<T>::from(from[i], token, serializer);

      token.name = DataRef("");
      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  template<typename Key, typename Value, typename Map>
  struct TypeHandlerMap {
    static inline Error to(Map &to_type, ParseContext &context) {
      if (context.token.value_type != Type::ObjectStart) {
        return JS::Error::ExpectedObjectStart;
      }

      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      while (context.token.value_type != Type::ObjectEnd) {
        Key key(context.token.name.data, context.token.name.size);
        Value v;
        error = TypeHandler<Value>::to(v, context);
        to_type[std::move(key)] = std::move(v);
        if (error != JS::Error::NoError)
          return error;
        error = context.nextToken();
      }

      return error;
    }

    static void from(const Map &from, Token &token, Serializer &serializer) {
      token.value_type = Type::ObjectStart;
      token.value = DataRef("{");
      serializer.write(token);
      for (auto it = from.begin(); it != from.end(); ++it) {
        token.name = DataRef(it->first);
        token.name_type = Type::String;
        TypeHandler<Value>::from(it->second, token, serializer);
      }
      token.name.size = 0;
      token.name.data = "";
      token.name_type = Type::String;
      token.value_type = Type::ObjectEnd;
      token.value = DataRef("}");
      serializer.write(token);
    }
  };

#ifdef JS_STD_UNORDERED_MAP
  template<typename Key, typename Value>
  struct TypeHandler<std::unordered_map<Key, Value> > : TypeHandlerMap<Key, Value, std::unordered_map<Key, Value> > {
  };

#endif

  namespace Internal {
    inline bool compareDataRefWithString(const DataRef &a, const std::string &b) {
      return a.size == b.size() && memcmp(a.data, b.data(), a.size) == 0;
    }
  } // namespace Internal
  struct Map {
    struct It {
      using iterator_category = std::forward_iterator_tag;
      using difference_type = int;
      using value_type = Token;
      using pointer = Token *;
      using reference = Token &;
      const Map &map;
      uint32_t index = 0;
      uint32_t next_meta = 0;
      uint32_t next_complex = 0;

      It(const Map &map)
        : map(map) {
      }

      It(const It &other)
        : map(other.map)
          , index(other.index)
          , next_meta(other.next_meta)
          , next_complex(other.next_complex) {
      }

      inline const Token &operator*() {
        return map.tokens.data[index];
      }

      inline const Token *operator->() {
        return &map.tokens.data[index];
      }

      inline It &operator++() {
        if (index == next_complex) {
          index += map.meta[next_meta].size;
          next_meta += map.meta[next_meta].skip;
          next_complex = next_meta < uint32_t(map.meta.size())
                           ? uint32_t(map.meta[next_meta].position)
                           : uint32_t(map.tokens.data.size());
        } else {
          index++;
        }
        return *this;
      }

      inline bool operator==(const It &other) const {
        return index == other.index;
      }

      inline bool operator!=(const It &other) const {
        return index != other.index;
      }

      inline void operator=(const It &other) {
        assert(&map == &other.map);
        index = other.index;
        next_meta = other.next_meta;
        next_complex = other.next_complex;
      }
    };

    JS::JsonTokens tokens;
    std::vector<JsonMeta> meta;
    std::vector<std::pair<int, std::string> > json_data;

    inline It begin() const {
      It b(*this);
      b.index = 1;
      b.next_meta = 1;
      b.next_complex =
          b.next_meta < uint32_t(meta.size()) ? uint32_t(meta[b.next_meta].position) : uint32_t(tokens.data.size());
      return b;
    }

    inline It end() const {
      It e(*this);
      e.index = uint32_t(tokens.data.size());
      e.next_meta = 0;
      e.next_complex = 0;
      return e;
    }

    inline It find(const std::string &name) const {
      return std::find_if(begin(), end(),
                          [&name](const Token &token) { return Internal::compareDataRefWithString(token.name, name); });
    }

    template<typename T>
    JS::Error castToType(JS::ParseContext &parseContext, T &to) const {
      parseContext.tokenizer.resetData(&tokens.data, 0);
      parseContext.nextToken();
      return JS::TypeHandler<T>::to(to, parseContext);
    }

    template<typename T>
    JS::Error castToType(const It &iterator, JS::ParseContext &parseContext, T &to) const {
      assert(iterator.index < tokens.data.size());
      parseContext.tokenizer.resetData(&tokens.data, iterator.index);
      parseContext.nextToken();
      return JS::TypeHandler<T>::to(to, parseContext);
    }

    template<typename T>
    JS::Error castToType(const std::string &name, JS::ParseContext &parseContext, T &to) const {
      if (tokens.data.empty() || tokens.data.front().value_type != JS::Type::ObjectStart) {
        parseContext.error = JS::Error::ExpectedObjectStart;
        return parseContext.error;
      }

      It it = find(name);
      if (it != end())
        return castToType(it, parseContext, to);
      parseContext.error = JS::Error::KeyNotFound;
      return parseContext.error;
    }

    template<typename T>
    T castTo(JS::ParseContext &parseContext) const {
      T t = {};
      castToType<T>(parseContext, t);
      return t;
    }

    template<typename T>
    T castTo(const std::string &name, JS::ParseContext &parseContext) const {
      T t = {};
      castToType<T>(name, parseContext, t);
      return t;
    }

    template<typename T>
    JS::Error setValue(JS::ParseContext &parseContext, const T &value) {
      static_assert(sizeof(JS::Internal::HasJsonStructBase<T>::template test_in_base<T>(nullptr)) ==
                    sizeof(typename JS::Internal::HasJsonStructBase<T>::yes),
                    "Not a Json Object type\n");
      std::string obj = JS::serializeStruct(value);
      parseContext.tokenizer.resetData(obj.data(), obj.size(), 0);
      tokens.data.clear();
      meta.clear();
      json_data.clear();
      auto error = parseContext.parseTo(tokens);
      if (error == JS::Error::NoError)
        assert(tokens.data.size() && tokens.data[0].value_type == JS::Type::ObjectStart);

      meta = metaForTokens(tokens);
      json_data.emplace_back(0, std::move(obj));
      return parseContext.error;
    }

    template<typename T>
    JS::Error setValue(const std::string &name, JS::ParseContext &parseContext, const T &value) {
      (void) parseContext;
      if (tokens.data.empty()) {
        tokens.data.reserve(10);
        meta.reserve(10);
        JS::Token token;
        token.value_type = JS::Type::ObjectStart;
        token.value = JS::DataRef("{");
        tokens.data.push_back(token);
        token.value_type = JS::Type::ObjectEnd;
        token.value = JS::DataRef("}");
        tokens.data.push_back(token);
        meta = JS::metaForTokens(tokens);
      }

      auto it = find(name);
      if (it != end()) {
        meta[0].children--;
        int tokens_removed = 0;
        if (it.index == it.next_complex) {
          auto theMeta = meta[it.next_meta];
          tokens_removed = theMeta.size;
          meta[0].complex_children--;
          meta[0].size -= theMeta.size;
          meta[0].skip -= theMeta.skip;
          auto start_token = tokens.data.begin() + it.index;
          tokens.data.erase(start_token, start_token + theMeta.size);
          int to_adjust_index = it.next_meta;
          auto start_meta = meta.begin() + it.next_meta;
          meta.erase(start_meta, start_meta + theMeta.skip);
          for (int i = to_adjust_index; i < int(meta.size()); i++) {
            meta[i].position -= theMeta.size;
          }
        } else {
          meta[0].size--;
          tokens.data.erase(tokens.data.begin() + it.index);
          tokens_removed = 1;
        } {
          int index_to_remove = -1;
          for (int i = 0; i < int(json_data.size()); i++) {
            if (uint32_t(json_data[i].first) == it.index)
              index_to_remove = i;
            else if (uint32_t(json_data[i].first) > it.index)
              json_data[i].first -= tokens_removed;
          }
          if (index_to_remove >= 0) {
            json_data.erase(json_data.begin() + index_to_remove);
          }
        }
      }
      static const char objectStart[] = "{";
      static const char objectEnd[] = "}";
      std::string out;
      JS::SerializerContext serializeContext(out);
      serializeContext.serializer.setOptions(SerializerOptions(JS::SerializerOptions::Compact));
      JS::Token token;
      token.value_type = Type::ObjectStart;
      token.value = DataRef(objectStart);
      serializeContext.serializer.write(token);

      token.name = DataRef(name);
      token.name_type = Type::String;
      JS::TypeHandler<T>::from(value, token, serializeContext.serializer);

      token.name = DataRef();
      token.value_type = Type::ObjectEnd;
      token.value = DataRef(objectEnd);
      serializeContext.serializer.write(token);

      serializeContext.flush();
      JS::JsonTokens new_tokens;
      JS::ParseContext pc(out.c_str(), out.size(), new_tokens);
      auto new_meta = metaForTokens(new_tokens);

      json_data.emplace_back(int(tokens.data.size() - 1), std::move(out));
      int old_tokens_size = int(tokens.data.size());
      tokens.data.insert(tokens.data.end() - 1, new_tokens.data.begin() + 1, new_tokens.data.end() - 1);
      meta[0].children++;
      if (new_meta[0].complex_children) {
        meta[0].complex_children++;
        meta[0].size += new_meta[1].size;
        meta[0].skip += new_meta[1].skip;
        int old_meta_size = int(meta.size());
        meta.insert(meta.end(), new_meta.begin() + 1, new_meta.end());
        for (int new_meta_i = old_meta_size; new_meta_i < int(meta.size()); new_meta_i++) {
          meta[new_meta_i].position +=
              old_tokens_size - 1 - 1; // position contains an extra and old_tokens_size has another extra
        }
      } else {
        meta[0].size++;
      }

      return JS::Error::NoError;
    }
  };

  template<>
  struct TypeHandler<Map> {
    static inline Error to(Map &to_type, ParseContext &context) {
      Error error = TypeHandler<JS::JsonTokens>::to(to_type.tokens, context);
      if (error == Error::NoError) {
        to_type.meta = metaForTokens(to_type.tokens);
      }

      return error;
    }

    static inline void from(const Map &from_type, Token &, Serializer &serializer) {
      for (auto &token: from_type.tokens.data) {
        serializer.write(token);
      }
    }
  };

  template<typename T, size_t COUNT>
  struct ArrayVariableContent {
    T data[COUNT];
    size_t size = 0;
  };

  template<typename T, size_t COUNT>
  struct TypeHandler<ArrayVariableContent<T, COUNT> > {
    static inline Error to(ArrayVariableContent<T, COUNT> &to_type, ParseContext &context) {
      if (context.token.value_type != Type::ArrayStart)
        return JS::Error::ExpectedArrayStart;

      context.nextToken();
      for (size_t i = 0; i < COUNT; i++) {
        if (context.error != JS::Error::NoError)
          return context.error;
        if (context.token.value_type == Type::ArrayEnd) {
          to_type.size = i;
          break;
        }
        context.error = TypeHandler<T>::to(to_type.data[i], context);
        if (context.error != JS::Error::NoError)
          return context.error;

        context.nextToken();
      }

      if (context.token.value_type != Type::ArrayEnd)
        return JS::Error::ExpectedArrayEnd;
      return context.error;
    }

    static inline void from(const ArrayVariableContent<T, COUNT> &from_type, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");
      for (size_t i = 0; i < from_type.size; i++)
        TypeHandler<T>::from(from_type.data[i], token, serializer);

      token.name = DataRef("");
      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };

  template<typename T, typename Set>
  struct TypeHandlerSet {
    static inline Error to(Set &to_type, ParseContext &context) {
      if (context.token.value_type != JS::Type::ArrayStart)
        return Error::ExpectedArrayStart;
      Error error = context.nextToken();
      if (error != JS::Error::NoError)
        return error;
      to_type.clear();
      while (context.token.value_type != JS::Type::ArrayEnd) {
        T t;
        error = TypeHandler<T>::to(t, context);
        if (error != JS::Error::NoError)
          break;
        auto insert_ret = to_type.insert(std::move(t));
        if (!insert_ret.second)
          return JS::Error::DuplicateInSet;

        error = context.nextToken();
        if (error != JS::Error::NoError)
          break;
      }

      return error;
    }

    static inline void from(const Set &set, Token &token, Serializer &serializer) {
      token.value_type = Type::ArrayStart;
      token.value = DataRef("[");
      serializer.write(token);

      token.name = DataRef("");

      for (auto &index: set) {
        TypeHandler<T>::from(index, token, serializer);
      }

      token.name = DataRef("");

      token.value_type = Type::ArrayEnd;
      token.value = DataRef("]");
      serializer.write(token);
    }
  };
} // namespace JS
#endif // JSON_STRUCT_H

#if defined(JS_STL_MAP) && !defined(JS_STL_MAP_INCLUDE)
#define JS_STL_MAP_INCLUDE
#include <map>
namespace JS
{
template <typename Key, typename Value>
struct TypeHandler<std::map<Key, Value>> : TypeHandlerMap<Key, Value, std::map<Key, Value>>
{
};
} // namespace JS
#endif

#if defined(JS_STL_SET) && !defined(JS_STL_SET_INCLUDE)
#define JS_STL_SET_INCLUDE
#include <set>
namespace JS
{
template <typename Key>
struct TypeHandler<std::set<Key>> : TypeHandlerSet<Key, std::set<Key>>
{
};
} // namespace JS
#endif

#if defined(JS_STL_UNORDERED_SET) && !defined(JS_STL_UNORDERED_SET_INCLUDE)
#define JS_STL_UNORDERED_SET_INCLUDE
#include <unordered_set>
namespace JS
{
template <typename Key>
struct TypeHandler<std::unordered_set<Key>> : TypeHandlerSet<Key, std::unordered_set<Key>>
{
};
} // namespace JS
#endif

#if defined(JS_STL_ARRAY) && !defined(JS_STL_ARRAY_INCLUDE)
#define JS_STL_ARRAY_INCLUDE
#include <array>
namespace JS
{
template <typename T, size_t N>
struct TypeHandler<std::array<T,N>>
{
public:
  static inline Error to(std::array<T,N> &to_type, ParseContext &context)
  {
    if (context.token.value_type != Type::ArrayStart)
      return JS::Error::ExpectedArrayStart;

    context.nextToken();
    for (size_t i = 0; i < N; i++)
    {
      if (context.error != JS::Error::NoError)
        return context.error;
      context.error = TypeHandler<T>::to(to_type[i], context);
      if (context.error != JS::Error::NoError)
        return context.error;

      context.nextToken();
    }

    if (context.token.value_type != Type::ArrayEnd)
      return JS::Error::ExpectedArrayEnd;
    return context.error;
  }
  static void from(const std::array<T,N> &from, Token &token, Serializer &serializer)
  {
    token.value_type = Type::ArrayStart;
    token.value = DataRef("[");
    serializer.write(token);

    token.name = DataRef("");
    for (size_t i = 0; i < N; i++)
      TypeHandler<T>::from(from[i], token, serializer);

    token.name = DataRef("");
    token.value_type = Type::ArrayEnd;
    token.value = DataRef("]");
    serializer.write(token);
  }
};
} // namespace JS
#endif

#if defined(JS_INT_128) && !defined(JS_INT_128_INCLUDE)
#define JS_INT_128_INCLUDE 1
// Compiler support check
#if defined(__SIZEOF_INT128__) && !defined(JS_NO_INT128_TYPEDEF)
namespace JS
{
__extension__ using js_int128_t = __int128;
__extension__ using js_uint128_t = unsigned __int128;
} // namespace JS
#endif

namespace JS
{
/// \private
template <>
struct TypeHandler<js_int128_t> : TypeHandlerIntType<js_int128_t>
{
};

/// \private
template <>
struct TypeHandler<js_uint128_t> : TypeHandlerIntType<js_uint128_t>
{
};
} // namespace JS
#endif
