/home/runner/work/json5cpp/json5cpp/src/parse.hpp

Source (jump to first uncovered line)

#pragma once

#include <string_view>
#include <stack>
#include <cmath>
#include <limits>
#include <variant>
#include <string>
#include <iostream>
#include <vector>
#include <map>
#include <optional>
#include <cstdio>
#include <cassert>
#include <cstdint>

#include "utf8.hpp"
#include "util.hpp"
#include "jsonvalue.hpp"
#include "parserstate.hpp"
#include "token.hpp"

namespace JSON5 {

const char32_t EndOfInput = char32_t(-1);

class EncodingBuffer {
  std::string data {};
public:
  EncodingBuffer& operator=(char32_t c) {
    data = toUTF8(c);
    return *this;
  }
  EncodingBuffer& operator+=(char32_t c) {
    data += toUTF8(c);
    return *this;
  }
  const std::string& str() { return data; }
  void clear() { data.clear(); }
};

struct SyntaxError: public std::runtime_error {
  const size_t lineNumber;
  const size_t columnNumber;
  SyntaxError(size_t line, size_t column, const std::string& message):
    std::runtime_error(message),
    lineNumber {line},
    columnNumber {column}
  {}
};

class Parser {

  std::string_view source;
  State parseState;
  std::stack<Value*> stack;
  size_t pos;
  size_t line;
  size_t column;
  Token token;
  std::string key;
  Value root;

public:
  Value parse(std::string_view text) {
    source = text;
    parseState = State::start;
    stack = {};
    pos = 0;
    line = 1;
    column = 0;
    token = incomplete;
    key = "";
    root = null;

    do {
      token = lex();

      // This code is unreachable.
      // if (!parseStates[parseState]) {
      //     throw invalidParseState()
      // }

      consumeToken(parseState);
    } while (token.type != TokenType::eof);

    // if (typeof reviver === 'function') {
    //     return internalize({'': root}, '', reviver)
    // }

    return root;
  }
private:

  State lexState;
  EncodingBuffer buffer;
  bool doubleQuote;
  int sign;
  char32_t c;

  Token lex() {
    lexState = State::deflt;
    buffer.clear();
    doubleQuote = false;
    sign = 1;

    for (;;) {
      c = peek().c;

      // This code is unreachable.;
      // if (!lexStates[lexState]) {
      //     throw invalidLexState(lexState);
      // };

      const Token token = consumeCharacter(lexState);
      if (token.type != TokenType::incomplete) {
        return token;
      }
    }
  }

  struct Peek { char32_t c; uint32_t n; };
  Peek peek() {
    const UTF8Peek result = peekUTF8(source.substr(pos));
    switch (result.status) {
      case UTF8Peek::Status::ok: return {result.codepoint, result.bytesRead};
      case UTF8Peek::Status::endOfString: return {EndOfInput, 0};
      case UTF8Peek::Status::invalid: throw invalidUnicode();
    }
    assert(false); // suppress "control reaches end of non-void function" warning
  }

  char32_t read() {
    const auto [c, n] = peek();

    if (c == '\n') {
      line++;
      column = 0;
    } else if (c != EndOfInput) {
      column += 1;
    } else {
      column++;
    }

    if (c != EndOfInput) {
      pos += n;
    }

    return c;
  }

  Token consumeCharacter(State s) {
    switch (s) {
      case State::deflt: {
        switch (c) {
          case '\t':
          case '\v':
          case '\f':
          case ' ':
          case 0x00A0:
          case 0xFEFF:
          case '\n':
          case '\r':
          case 0x2028:
          case 0x2029:
            read();
            return incomplete;

          case '/':
            read();
            lexState = State::comment;
            return incomplete;

          case EndOfInput:
            read();
            return newToken(TokenType::eof);
        }

        if (util::isSpaceSeparator(c)) {
          read();
          return incomplete;
        }

        // This code is unreachable.;
        // if (!lexStates[parseState]) {
        //     throw invalidLexState(parseState);
        // };

        return consumeCharacter(parseState);
      }

      case State::comment: {
        switch (c) {
          case '*':
            read();
            lexState = State::multiLineComment;
            return incomplete;

          case '/':
            read();
            lexState = State::singleLineComment;
            return incomplete;
        }

        throw invalidChar(read());
      }

      case State::multiLineComment: {
        switch (c) {
          case '*':
            read();
            lexState = State::multiLineCommentAsterisk;
            return incomplete;

          case EndOfInput:
            throw invalidChar(read());
        }

        read();
      } break;

      case State::multiLineCommentAsterisk: {
        switch (c) {
          case '*':
            read();
            return incomplete;

          case '/':
            read();
            lexState = State::deflt;
            return incomplete;

          case EndOfInput:
            throw invalidChar(read());
        }

        read();
        lexState = State::multiLineComment;
      } break;

      case State::singleLineComment: {
        switch (c) {
          case '\n':
          case '\r':
          case 0x2028:
          case 0x2029:
            read();
            lexState = State::deflt;
            return incomplete;

          case EndOfInput:
            read();
            return newToken(TokenType::eof);
        }

        read();
      } break;

      case State::value: {
        switch (c) {
          case '{':
          case '[':
            return newToken(TokenType::punctuator, read());

          case 'n':
            read();
            literal("ull");
            return newToken(TokenType::null, null);

          case 't':
            read();
            literal("rue");
            return newToken(TokenType::boolean, Value {true});

          case 'f':
            read();
            literal("alse");
            return newToken(TokenType::boolean, Value {false});

          case '-':
          case '+':
            if (read() == '-') {
              sign = -1;
            }

            lexState = State::sign;
            return incomplete;

          case '.':
            buffer = read();
            lexState = State::decimalPointLeading;
            return incomplete;

          case '0':
            buffer = read();
            lexState = State::zero;
            return incomplete;

          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7':
          case '8':
          case '9':
            buffer = read();
            lexState = State::decimalInteger;
            return incomplete;

          case 'I':
            read();
            literal("nfinity");
            return newToken(TokenType::numeric, std::numeric_limits<double>::infinity());

          case 'N':
            read();
            literal("aN");
            return newToken(TokenType::numeric, std::nan(""));

          case '"':
          case '\'':
            doubleQuote = (read() == '"');
            buffer.clear();
            lexState = State::string;
            return incomplete;
        }

        throw invalidChar(read());
      }

      case State::identifierNameStartEscape: {
        if (c != 'u') {
          throw invalidChar(read());
        }

        read();
        const char32_t u = unicodeEscape();
        switch (u) {
          case '$':
          case '_':
            break;

          default:
            if (!util::isIdStartChar(u)) {
              throw invalidIdentifier();
            }

            break;
        }

        buffer += u;
        lexState = State::identifierName;
      } break;

      case State::identifierName: {
        switch (c) {
          case '$':
          case '_':
          case 0x200C:
          case 0x200D:
            buffer += read();
            return incomplete;

          case '\\':
            read();
            lexState = State::identifierNameEscape;
            return incomplete;
        }

        if (util::isIdContinueChar(c)) {
          buffer += read();
          return incomplete;
        }

        return newToken(TokenType::identifier, buffer.str());
      }

      case State::identifierNameEscape: {
        if (c != 'u') {
          throw invalidChar(read());
        }

        read();
        const char32_t u = unicodeEscape();
        switch (u) {
          case '$':
          case '_':
          case 0x200C:
          case 0x200D:
            break;

          default:
            if (!util::isIdContinueChar(u)) {
              throw invalidIdentifier();
            }

            break;
        }

        buffer += u;
        lexState = State::identifierName;
      } break;

      case State::sign: {
        switch (c) {
          case '.':
            buffer = read();
            lexState = State::decimalPointLeading;
            return incomplete;

          case '0':
            buffer = read();
            lexState = State::zero;
            return incomplete;

          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7':
          case '8':
          case '9':
            buffer = read();
            lexState = State::decimalInteger;
            return incomplete;

          case 'I':
            read();
            literal("nfinity");
            return newToken(TokenType::numeric, sign * std::numeric_limits<double>::infinity());

          case 'N':
            read();
            literal("aN");
            return newToken(TokenType::numeric, std::nan(""));
        }

        throw invalidChar(read());
      }

      case State::zero: {
        switch (c) {
          case '.':
            buffer += read();
            lexState = State::decimalPoint;
            return incomplete;

          case 'e':
          case 'E':
            buffer += read();
            lexState = State::decimalExponent;
            return incomplete;

          case 'x':
          case 'X':
            buffer += read();
            lexState = State::hexadecimal;
            return incomplete;
        }

        return newToken(TokenType::numeric, sign * 0.0);
      }

      case State::decimalInteger: {
        switch (c) {
          case '.':
            buffer += read();
            lexState = State::decimalPoint;
            return incomplete;

          case 'e':
          case 'E':
            buffer += read();
            lexState = State::decimalExponent;
            return incomplete;
        }

        if (util::isDigit(c)) {
          buffer += read();
          return incomplete;
        }

        return newToken(TokenType::numeric, sign * std::stod(buffer.str()));
      }

      case State::decimalPointLeading: {
        if (util::isDigit(c)) {
          buffer += read();
          lexState = State::decimalFraction;
          return incomplete;
        }

        throw invalidChar(read());
      }

      case State::decimalPoint: {
        switch (c) {
          case 'e':
          case 'E':
            buffer += read();
            lexState = State::decimalExponent;
            return incomplete;
        }

        if (util::isDigit(c)) {
          buffer += read();
          lexState = State::decimalFraction;
          return incomplete;
        }

        return newToken(TokenType::numeric, sign * std::stod(buffer.str()));
      }

      case State::decimalFraction: {
        switch (c) {
          case 'e':
          case 'E':
            buffer += read();
            lexState = State::decimalExponent;
            return incomplete;
        }

        if (util::isDigit(c)) {
          buffer += read();
          return incomplete;
        }

        return newToken(TokenType::numeric, sign * std::stod(buffer.str()));
      }

      case State::decimalExponent: {
        switch (c) {
          case '+':
          case '-':
            buffer += read();
            lexState = State::decimalExponentSign;
            return incomplete;
        }

        if (util::isDigit(c)) {
          buffer += read();
          lexState = State::decimalExponentInteger;
          return incomplete;
        }

        throw invalidChar(read());
      }

      case State::decimalExponentSign: {
        if (util::isDigit(c)) {
          buffer += read();
          lexState = State::decimalExponentInteger;
          return incomplete;
        }

        throw invalidChar(read());
      }

      case State::decimalExponentInteger: {
        if (util::isDigit(c)) {
          buffer += read();
          return incomplete;
        }

        return newToken(TokenType::numeric, sign * std::stod(buffer.str()));
      }

      case State::hexadecimal: {
        if (util::isHexDigit(c)) {
          buffer += read();
          lexState = State::hexadecimalInteger;
          return incomplete;
        }

        throw invalidChar(read());
      }

      case State::hexadecimalInteger: {
        if (util::isHexDigit(c)) {
          buffer += read();
          return incomplete;
        }

        return newToken(TokenType::numeric, sign * std::stod(buffer.str()));
      }

      case State::string: {
        switch (c) {
          case '\\':
            read();
            { auto esc = escape(); if (esc) { buffer += *esc; }12 }
            return incomplete;

          case '"':
            if (doubleQuote) {
              read();
              return newToken(TokenType::string, buffer.str());
            }

            buffer += read();
            return incomplete;

          case '\'':
            if (!doubleQuote) {
              read();
              return newToken(TokenType::string, buffer.str());
            }

            buffer += read();
            return incomplete;

          case '\n':
          case '\r':
            throw invalidChar(read());

          case 0x2028:
          case 0x2029:
            separatorChar(c);
            break;

          case EndOfInput:
            throw invalidChar(read());
        }

        buffer += read();
      } break;

      case State::start: {
        switch (c) {
          case '{':
          case '[':
            return newToken(TokenType::punctuator, read());

            // This code is unreachable since the default lexState handles eof.;
            // case EndOfInput:
            //     return newToken(TokenType::eof);
        }

        lexState = State::value;
      } break;

      case State::beforePropertyName: {
        switch (c) {
          case '$':
          case '_':
            buffer = read();
            lexState = State::identifierName;
            return incomplete;

          case '\\':
            read();
            lexState = State::identifierNameStartEscape;
            return incomplete;

          case '}':
            return newToken(TokenType::punctuator, read());

          case '"':
          case '\'':
            doubleQuote = (read() == '"');
            lexState = State::string;
            return incomplete;
        }

        if (util::isIdStartChar(c)) {
          buffer += read();
          lexState = State::identifierName;
          return incomplete;
        }

        throw invalidChar(read());
      }

      case State::afterPropertyName: {
        if (c == ':') {
          return newToken(TokenType::punctuator, read());
        }

        throw invalidChar(read());
      }

      case State::beforePropertyValue: {
        lexState = State::value;
      } break;

      case State::afterPropertyValue: {
        switch (c) {
          case ',':
          case '}':
            return newToken(TokenType::punctuator, read());
        }

        throw invalidChar(read());
      }

      case State::beforeArrayValue: {
        if (c == ']') {
          return newToken(TokenType::punctuator, read());
        }

        lexState = State::value;
      } break;

      case State::afterArrayValue: {
        switch (c) {
          case ',':
          case ']':
            return newToken(TokenType::punctuator, read());
        }

        throw invalidChar(read());
      }

      case State::end: {
        // This code is unreachable since it's handled by the default lexState.;
        // if (c == EndOfInput) {
        //     read();
        //     return newToken(TokenType::eof);
        // }

        throw invalidChar(read());
      }
    }

    return incomplete;
  }

  Token newToken(TokenType type, std::variant<Value, char32_t> value = null) {
    return {
      type,
      value,
      line,
      column,
    };
  }

  void literal(const std::string& s) {
    for (const char& c: s) {
      const char32_t p = peek().c;

      if (p != char32_t(c)) {
        throw invalidChar(read());
      }

      read();
    }
  }

  std::optional<char32_t> escape() {
    const char32_t c = peek().c;
    switch (c) {
      case 'b':
        read();
        return '\b';

      case 'f':
        read();
        return '\f';

      case 'n':
        read();
        return '\n';

      case 'r':
        read();
        return '\r';

      case 't':
        read();
        return '\t';

      case 'v':
        read();
        return '\v';

      case '0':
        read();
        if (util::isDigit(peek().c)) {
          throw invalidChar(read());
        }

        return '\0';

      case 'x':
        read();
        return hexEscape();

      case 'u':
        read();
        return unicodeEscape();

      case '\n':
      case 0x2028:
      case 0x2029:
        read();
        return std::nullopt;

      case '\r':
        read();
        if (peek().c == '\n') {
          read();
        }

        return std::nullopt;

      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        throw invalidChar(read());

      case EndOfInput:
        throw invalidChar(read());
    }

    return read();
  }

  char32_t hexEscape() {
    std::string buffer = "";
    char32_t c = peek().c;

    if (!util::isHexDigit(c)) {
      throw invalidChar(read());
    }

    buffer += read();

    c = peek().c;
    if (!util::isHexDigit(c)) {
      throw invalidChar(read());
    }

    buffer += read();

    return char32_t(std::stoi(buffer, 0, 16));
  }

  char32_t unicodeEscape() {
    std::string buffer = "";
    uint8_t count = 4;

    while (count-- > 0) {
      const char32_t c = peek().c;
      if (!util::isHexDigit(c)) {
        throw invalidChar(read());
      }

      buffer += read();
    }

    return char32_t(std::stoi(buffer, 0, 16));
  }

  void consumeToken(State s) {
    switch (s) {
      case State::start: {
        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        push();
      } break;

      case State::beforePropertyName: {
        switch (token.type) {
          case TokenType::identifier:
          case TokenType::string:
            key = std::get<std::string>(std::get<Value>(token.value));
            parseState = State::afterPropertyName;
            return;

          case TokenType::punctuator:
            // This code is unreachable since it's handled by the lexState.;
            // if (token.value != '}') {
            //     throw invalidToken();
            // }

            pop();
            return;

          case TokenType::eof:
            throw invalidEOF();

          default:; // suppress unhandled case warning
        }

        // This code is unreachable since it's handled by the lexState.;
        // throw invalidToken();
      }

      case State::afterPropertyName: {
        // This code is unreachable since it's handled by the lexState.;
        // if (token.type != TokenType::punctuator || token.value != ':') {
        //     throw invalidToken();
        // }

        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        parseState = State::beforePropertyValue;
      } break;

      case State::beforePropertyValue: {
        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        push();
      } break;

      case State::beforeArrayValue: {
        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        if (token.type == TokenType::punctuator && std::get<char32_t>(token.value) == ']'2) {
          pop();
          return;
        }

        push();
      } break;

      case State::afterPropertyValue: {
        // This code is unreachable since it's handled by the lexState.;
        // if (token.type != TokenType::punctuator) {
        //     throw invalidToken();
        // }

        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        switch (std::get<char32_t>(token.value)) {
          case ',':
            parseState = State::beforePropertyName;
            return;

          case '}':
            pop();
        }

        // This code is unreachable since it's handled by the lexState.;
        // throw invalidToken();
      } break11;

      case State::afterArrayValue: {
        // This code is unreachable since it's handled by the lexState.;
        // if (token.type != TokenType::punctuator) {
        //     throw invalidToken();
        // }

        if (token.type == TokenType::eof) {
          throw invalidEOF();
        }

        switch (std::get<char32_t>(token.value)) {
          case ',':
            parseState = State::beforeArrayValue;
            return;

          case ']':
            pop();
        }

        // This code is unreachable since it's handled by the lexState.;
        // throw invalidToken();
      } break13;

      case State::end: {
        // This code is unreachable since it's handled by the lexState.;
        // if (token.type != TokenType::eof) {
        //     throw invalidToken();
        // }
      }

      default:; // suppress unhandled case warning
    }
  }

  void push() {
    Value temp;

    switch (token.type) {
      case TokenType::punctuator:
        switch (std::get<char32_t>(token.value)) {
          case '{':
            temp = Object {};
            break;

          case '[':
            temp = Array {};
            break;
        }

        break;

      case TokenType::null:
      case TokenType::boolean:
      case TokenType::numeric:
      case TokenType::string:
        temp = std::get<Value>(token.value);
        break;

      default:; // suppress unhandled case warning
        // This code is unreachable.;
        // default:
        //     throw invalidToken();
    }

    Value* value;
    if (stack.size() == 0) {
      root = temp;
      value = &root;
    } else {
      Value& parent = *stack.top();
      if (isArray(parent)) {
        std::get<Array>(parent).push_back(temp);
        value = &std::get<Array>(parent).back();
      } else {
        // auto result = std::get<Object>(parent).insert({key, temp});
        // if (!result.second) {
        //  throw std::runtime_error("Key " + key + " already exists in object");
        // }
        // value = &(result.first->second);
        auto result = std::get<Object>(parent).insert_or_assign(key, temp);
        value = &(result.first->second);
      }
    }

    if ((isObject(*value) || isArray(*value)86)) {
      stack.push(value);

      if (isArray(*value)) {
        parseState = State::beforeArrayValue;
      } else {
        parseState = State::beforePropertyName;
      }
    } else {
      if (stack.size() == 0) {
        parseState = State::end;
      }
      else {
        const Value& current = *stack.top();
        if (isArray(current)) {
          parseState = State::afterArrayValue;
        } else {
          parseState = State::afterPropertyValue;
        }
      }
    }
  }

  void pop() {
    stack.pop();

    if (stack.size() == 0) {
      parseState = State::end;
    }
    else {
      const Value& current = *stack.top();
      if (isArray(current)) {
        parseState = State::afterArrayValue;
      } else {
        parseState = State::afterPropertyValue;
      }
    }
  }

  // This code is unreachable.;
  // std::runtime_error invalidParseState () {
  //     return new Error("JSON5: invalid parse state '" + std::to_string(parseState) + "'");
  // }

  // This code is unreachable.;
  // std::runtime_error invalidLexState (state) {
  //     return new Error("JSON5: invalid lex state '" + std::to_string(state) + "'");
  // }

  SyntaxError invalidChar(char32_t c) {
    if (c == EndOfInput) {
      return syntaxError( "JSON5: invalid end of input at " + std::to_string(line) + ":" + std::to_string(column) + "");
    }

    return syntaxError("JSON5: invalid character '" + formatChar(c) + "' at " + std::to_string(line) + ":" + std::to_string(column) + "");
  }

  SyntaxError invalidUnicode() {
    column += 1;
    return syntaxError( "JSON5: invalid unicode byte sequence at " + std::to_string(line) + ":" + std::to_string(column) + "");
  }

  SyntaxError invalidEOF() {
    return syntaxError( "JSON5: invalid end of input at " + std::to_string(line) + ":" + std::to_string(column) + "");
  }

  // This code is unreachable.;
  // std::runtime_error invalidToken () {
  //     if (token.type == TokenType::eof) {
  //         return syntaxError("JSON5: invalid end of input at " + std::to_string(line) + ":" + std::to_string(column) + "");
  //     }

  //     const auto c = char32_t(token.value.codePointAt(0));
  //     return syntaxError("JSON5: invalid character '" + formatChar(c) + "' at " + std::to_string(line) + ":" + std::to_string(column) + "");
  // }

  SyntaxError invalidIdentifier() {
    column -= 5;
    return syntaxError( "JSON5: invalid identifier character at " + std::to_string(line) + ":" + std::to_string(column) + "");
  }

  void separatorChar(char32_t c) {
    std::cerr << ("JSON5: '" + formatChar(c) + "' in strings is not valid ECMAScript; consider escaping");
  }

  std::string formatChar(char32_t c) {
    const std::map<char32_t, std::string> replacements = {
      {'\'', "\\'"},
      {'"', "\\\""},
      {'\\', "\\\\"},
      {'\b', "\\b"},
      {'\f', "\\f"},
      {'\n', "\\n"},
      {'\r', "\\r"},
      {'\t', "\\t"},
      {'\v', "\\v"},
      {'\0', "\\0"},
      {0x2028, "\\u2028"},
      {0x2029, "\\u2029"},
    };

    if (replacements.count(c) > 0) {
      return replacements.at(c);
    }

    if (c < ' ') {
      char hexString[5];
      std::snprintf(hexString, sizeof(hexString),  "\\x%02X", c);
      return hexString;
    }

    return toUTF8(c);
  }

  SyntaxError syntaxError(const std::string& message) {
    return SyntaxError(line, column, message);
  }

};

Value parse(std::string_view text) {
  return Parser {}.parse(text);
}

}

/home/runner/work/json5cpp/json5cpp/src/stringify.hpp

Source (jump to first uncovered line)

#pragma once

#include <array>
#include <vector>
#include <string>
#include <optional>
#include <charconv>
#include <cstdint>

#include "utf8.hpp"
#include "util.hpp"
#include "jsonvalue.hpp"
#include "parserstate.hpp"
#include "token.hpp"

namespace JSON5 {

struct StringifyOptions {
  // int so the user can write {4} instead of {4u}
  std::variant<std::string, int> space;
  std::optional<char> quote = std::nullopt;
};

class Stringifier {
  std::string indent;
  //std::vector<std::string> propertyList;
  //let replacerFunc
  std::string gap;
  std::optional<char> quote;

  template <class>
  static inline constexpr bool always_false_v = false;

public:
  std::string stringify(
    const Value& value,
    const StringifyOptions options = {}
  ) {
    indent = "";
    //propertyList = {};
    //let replacerFunc
    gap = "";
    quote = options.quote;

    // if (
    //     replacer != null &&
    //     typeof replacer === 'object' &&
    //     !Array.isArray(replacer)
    // ) {
    //     space = replacer.space
    //     quote = replacer.quote
    //     replacer = replacer.replacer
    // }

    // if (typeof replacer === 'function') {
    //     replacerFunc = replacer
    // } else if (Array.isArray(replacer)) {
    //     propertyList = []
    //     for (const v of replacer) {
    //         let item

    //         if (typeof v === 'string') {
    //             item = v
    //         } else if (
    //             typeof v === 'number' ||
    //             v instanceof String ||
    //             v instanceof Number
    //         ) {
    //             item = String(v)
    //         }

    //         if (item !== undefined && propertyList.indexOf(item) < 0) {
    //             propertyList.push(item)
    //         }
    //     }
    // }

    // if (space instanceof Number) {
    //     space = Number(space)
    // } else if (space instanceof String) {
    //     space = String(space)
    // }

    // if (typeof space === 'number') {
    //     if (space > 0) {
    //         space = Math.min(10, Math.floor(space))
    //         gap = '          '.substr(0, space)
    //     }
    // } else if (typeof space === 'string') {
    //     gap = space.substr(0, 10)
    // }
    if (std::holds_alternative<int>(options.space)) {
      int i = std::get<int>(options.space);
      if (i < 0) { i = 0; }1
      if (i > 10) { i = 10; }1
      gap = std::string(i, ' ');
    }
    else {
      gap = std::get<std::string>(options.space).substr(0, 10);
    }
    return serializeProperty("", Object {{"", value}});
  }

private:
  void replaceAll(std::string& str, const std::string& from, const std::string& to) {
    size_t start_pos = 0;
    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
      str.replace(start_pos, from.length(), to);
      start_pos += to.length();
    }
  }

  std::string join(const std::vector<std::string>& items, const std::string& separator) {
    if (items.empty()) { return ""; }0
    std::string result = items[0];
    for (size_t i = 1; i < items.size(); ++i10) {
      result += separator + items[i];
    }
    return result;
  }

  template <typename K, typename H>
  std::string serializeProperty(const K& key, const H& holder) {
    const Value& value = holder.at(key);
    // if (!std::holds_alternative<Null>(value)) {
    //     if (typeof value.toJSON5 === 'function') {
    //         value = value.toJSON5(key)
    //     } else if (typeof value.toJSON === 'function') {
    //         value = value.toJSON(key)
    //     }
    // }

    // if (replacerFunc) {
    //     value = replacerFunc.call(holder, key, value)
    // }

    // if (value instanceof Number) {
    //     value = Number(value)
    // } else if (value instanceof String) {
    //     value = String(value)
    // } else if (value instanceof Boolean) {
    //     value = value.valueOf()
    // }

    return std::visit( [this](auto&& arg)
      {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, Null>) {0
          return std::string("null");
        }
        else if constexpr (2std::is_same_v<T, bool>) {0
          return std::string(arg2 ? "true"1 : "false"1);
        }
        else if constexpr (10std::is_same_v<T, std::string>) {0
          return quoteString(arg);
        }
        else if constexpr (39std::is_same_v<T, double>) {0
          if (std::isnan(arg)) { return std::string("NaN"); }1
          if (std::isinf(arg)) { return std::string(2arg > 02 ? "Infinity"1 : "-Infinity"1); }
          std::array<char, 64> buffer;
          auto result = std::to_chars(buffer.data(), buffer.data() + buffer.size(), arg);
          return std::string(buffer.data(), result.ptr - buffer.data());
        }
        else if constexpr (17std::is_same_v<T, Array>) {0
          return serializeArray(arg);
        }
        else if constexpr (std::is_same_v<T, Object>) {
          return serializeObject(arg);
        }
        else {
          static_assert(always_false_v<T>, "unhandled variant alternative");
        }
      }, value);
  }

  std::string quoteString(const std::string& value, bool = true) {
    size_t numSingleQuotes = 0;
    size_t numDoubleQuotes = 0;

    std::string product = "";

    std::string_view rest = value;
    while (rest.size() > 0) {
      const UTF8Peek peek = peekUTF8(rest);
      if (peek.status != UTF8Peek::Status::ok) {
        throw std::runtime_error("JSON5: invalid UTF-8 sequence in string");
      }
      const char32_t c = peek.codepoint;
      rest = rest.substr(peek.bytesRead);

      switch (c) {
        case '\'':
          numSingleQuotes++;
          product += c;
          continue;
        case '"':
          numDoubleQuotes++;
          product += c;
          continue;
        case '\0':
          product += util::isDigit(peekUTF8(rest).codepoint) ? "\\x00"2 : "\\0"4;
          continue;
        case '\\': product += "\\\\"; continue;
        case '\b': product += "\\b"; continue;
        case '\f': product += "\\f"; continue;
        case '\n': product += "\\n"; continue;
        case '\r': product += "\\r"; continue;
        case '\t': product += "\\t"; continue;
        case '\v': product += "\\v"; continue;
        case 0x2028: product += "\\u2028"; continue;
        case 0x2029: product += "\\u2029"; continue;
      }

      if (c < ' ') {
        char hexString[5];
        std::snprintf(hexString, sizeof(hexString),  "\\x%02X", c);
        product += hexString;
        continue;
      };

      product += c;

    }

    const char quoteChar = quote ? *quote4
      : (numSingleQuotes <= numDoubleQuotes)12 ? '\''9 : '"'3;

    replaceAll(product, std::string() + quoteChar, std::string("\\") + quoteChar);

    return quoteChar + product + quoteChar;
  }

  std::string serializeObject(const Object& value) {

    std::string stepback = indent;
    indent += gap;

    //let keys = propertyList || Object.keys(value);
    std::vector<std::string> partial = {};
    for (const auto& [key, _]: value) {
      const std::string propertyString = serializeProperty(key, value);
      //if (propertyString !== undefined) {
      std::string member = serializeKey(key) + ':';
      if (gap != "") {
        member += ' ';
      }
      member += propertyString;
      partial.push_back(member);
      //}
    }

    std::string final;
    if (partial.size() == 0) {
      final = "{}";
    }
    else {
      std::string properties;
      if (gap == "") {
        properties = join(partial, ",");
        final = '{' + properties + '}';
      }
      else {
        std::string separator = ",\n" + indent;
        properties = join(partial, separator);
        final = "{\n" + indent + properties + ",\n" + stepback + "}";
      }
    }

    indent = stepback;
    return final;
  }

  std::string serializeKey(const std::string& key) {
    if (key.size() == 0) {
      return quoteString(key, true);
    }

    const UTF8Peek firstChar = peekUTF8(key);
    if (firstChar.status != UTF8Peek::Status::ok) {
      throw std::runtime_error("JSON5: invalid UTF-8 sequence in key");
    }
    if (!util::isIdStartChar(firstChar.codepoint)) {
      return quoteString(key, true);
    }

    std::string_view rest = std::string_view(key).substr(firstChar.bytesRead);
    while (rest.size() > 0) {
      const UTF8Peek nextChar = peekUTF8(rest);
      if (nextChar.status != UTF8Peek::Status::ok) {
        throw std::runtime_error("JSON5: invalid UTF-8 sequence in key");
      }
      if (!util::isIdContinueChar(nextChar.codepoint)) {
        return quoteString(key, true);
      }
      rest = rest.substr(nextChar.bytesRead);
    }

    return key;
  }

  std::string serializeArray(const Array& value) {

    std::string stepback = indent;
    indent += gap;

    std::vector<std::string> partial = {};
    for (size_t i = 0; i < value.size(); i++23) {
      const std::string propertyString = serializeProperty(i, value);
      //partial.push((propertyString !== undefined) ? propertyString : 'null');
      partial.push_back(propertyString);
    }

    std::string final;
    if (partial.size() == 0) {
      final = "[]";
    }
    else {
      std::string properties;
      if (gap == "") {
        properties = join(partial, ",");
        final = '[' + properties + ']';
      }
      else {
        std::string separator = ",\n" + indent;
        properties = join(partial, separator);
        final = "[\n" + indent + properties + ",\n" + stepback + "]";
      }
    }

    indent = stepback;
    return final;
  }
};

std::string stringify(
  const Value& value,
  const StringifyOptions options = {}
) {
  return Stringifier {}.stringify(value, options);
}

}

/home/runner/work/json5cpp/json5cpp/src/utf8.hpp

Source

#pragma once

#include <iostream>
#include <string>
#include <string_view>
#include <cstdint>

struct UTF8Peek {
  char32_t codepoint;
  uint16_t bytesRead;

  enum class Status { ok, endOfString, invalid };
  Status status;
};

UTF8Peek peekUTF8(std::string_view source) {

  if (source.empty()) {
    return {char32_t(-1), 0, UTF8Peek::Status::endOfString};
  }

  uint8_t u_source0 = source[0];

  if (u_source0 <= 0b0111'1111) {
    return {u_source0, 1, UTF8Peek::Status::ok};
  }
  else if (
    (u_source0 & 0b1110'0000) == 0b1100'0000
    && source.size() >= 21.94k
    && (source[1] & 0b1100'0000) == 0b1000'00001.94k
  ) {
    return {
      ((char32_t(u_source0) & 0b0001'1111) << 6)
        | (char32_t(source[1]) & 0b0011'1111),
      2, UTF8Peek::Status::ok
    };
  }
  else if (
    (u_source0 & 0b1111'0000) == 0b1110'0000
    && source.size() >= 361.4k
    && (source[1] & 0b1100'0000) == 0b1000'000061.4k
    && (source[2] & 0b1100'0000) == 0b1000'000061.4k
  ) {
    char32_t cp = ((char32_t(u_source0) & 0b0000'1111) << 12)
      | ((char32_t(source[1]) & 0b0011'1111) << 6)
      | (char32_t(source[2]) & 0b0011'1111);

    // reject surrogate pairs
    if (cp < 0xd800 || cp > 0xdfff8.19k) {
      return {cp, 3, UTF8Peek::Status::ok};
    }
  }
  else if (
    (u_source0 & 0b1111'1000) == 0b1111'0000
    && source.size() >= 41.04M
    && (source[1] & 0b1100'0000) == 0b1000'00001.04M
    && (source[2] & 0b1100'0000) == 0b1000'00001.04M
    && (source[3] & 0b1100'0000) == 0b1000'00001.04M
  ) {
    char32_t cp = ((char32_t(u_source0) & 0b0000'0111) << 18)
      | ((char32_t(source[1]) & 0b0011'1111) << 12)
      | ((char32_t(source[2]) & 0b0011'1111) << 6)
      | (char32_t(source[3]) & 0b0011'1111);

    // U+10FFFF is the last valid unicode character
    if (cp <= 0x10ffff) {
      return {cp, 4, UTF8Peek::Status::ok};
    }
  }

  return {char32_t(-1), 0, UTF8Peek::Status::invalid};
}

std::string toUTF8(char32_t codepoint) {

  if (codepoint <= 0b1111111) {
    return {char(codepoint)};
  }
  else if (codepoint <= 0b11111'111111) {
    return {
      char((codepoint >> 6) | 0b1100'0000),
      char((codepoint & 0b0011'1111) | 0b1000'0000)
    };
  }
  else if (codepoint <= 0b1111'111111'111111) {
    if(codepoint >= 0xd800 && codepoint <= 0xdfff10.2k){
      return ""; // reject surrogate characters
    }
    return {
      char((codepoint >> 12) | 0b1110'0000),
      char(((codepoint >> 6) & 0b0011'1111) | 0b1000'0000),
      char((codepoint & 0b0011'1111) | 0b1000'0000)
    };
  } else if (codepoint <= 0x10FFFF) {
    return {
      char((codepoint >> 18) | 0b1111'0000),
      char(((codepoint >> 12) & 0b0011'1111) | 0b1000'0000),
      char(((codepoint >> 6) & 0b0011'1111) | 0b1000'0000),
      char((codepoint & 0b0011'1111) | 0b1000'0000)
    };
  }
  return "";
}

/home/runner/work/json5cpp/json5cpp/src/util.hpp

Line	Count	Source
1
2		#pragma once
3		#include <cstdint>
4		#include <unordered_set>
5
6		namespace util {
7
8	1.11M	bool isSpaceSeparator(char32_t c) {
9		// space and non-breaking space are handled explicitly in the code
10	1.11M	return c == 0x1680
11	1.11M	\|\| (1.11M c >= 0x20001.11M && c <= 0x200a1.10M )
12	1.11M	\|\| c == 0x202f1.11M
13	1.11M	\|\| c == 0x205f1.11M
14	1.11M	\|\| c == 0x30001.11M ;
15	1.11M	}
16
17	1.11M	bool isIdStartChar(char32_t c) {
18	1.11M	return (c >= 'a' && c <= 'z'1.11M )
19	1.11M	\|\| (1.11M c >= 'A'1.11M && c <= 'Z'1.11M )
20	1.11M	\|\| c == '$'1.11M
21	1.11M	\|\| c == '_'1.11M
22	1.11M	\|\| c == 0xaa1.11M \|\| c == 0xb51.11M \|\| c == 0xba1.11M \|\| (1.11M c >= 0xc01.11M && c <= 0xd61.11M )
23	1.11M	\|\| (1.11M c >= 0xd81.11M && c <= 0xf61.11M ) \|\| (1.11M c >= 0xf81.11M && c <= 0x2c11.11M ) \|\| (1.11M c >= 0x2c61.11M && c <= 0x2d11.11M ) \|\| (1.11M c >= 0x2e01.11M && c <= 0x2e41.11M )
24	1.11M	\|\| c == 0x2ec1.11M \|\| c == 0x2ee1.11M \|\| (1.11M c >= 0x3701.11M && c <= 0x3741.11M ) \|\| (1.11M c >= 0x3761.11M && c <= 0x3771.11M )
25	1.11M	\|\| (1.11M c >= 0x37a1.11M && c <= 0x37d1.11M ) \|\| c == 0x37f1.11M \|\| c == 0x3861.11M \|\| (1.11M c >= 0x3881.11M && c <= 0x38a1.11M )
26	1.11M	\|\| c == 0x38c1.11M \|\| (1.11M c >= 0x38e1.11M && c <= 0x3a11.11M ) \|\| (1.11M c >= 0x3a31.11M && c <= 0x3f51.11M ) \|\| (1.11M c >= 0x3f71.11M && c <= 0x4811.11M )
27	1.11M	\|\| (1.11M c >= 0x48a1.11M && c <= 0x52f1.11M ) \|\| (1.11M c >= 0x5311.11M && c <= 0x5561.11M ) \|\| c == 0x5591.11M \|\| (1.11M c >= 0x5611.11M && c <= 0x5871.11M )
28	1.11M	\|\| (1.11M c >= 0x5d01.11M && c <= 0x5ea1.11M ) \|\| (1.11M c >= 0x5f01.11M && c <= 0x5f21.11M ) \|\| (1.11M c >= 0x6201.11M && c <= 0x64a1.11M ) \|\| (1.11M c >= 0x66e1.11M && c <= 0x66f1.11M )
29	1.11M	\|\| (1.11M c >= 0x6711.11M && c <= 0x6d31.11M ) \|\| c == 0x6d51.11M \|\| (1.11M c >= 0x6e51.11M && c <= 0x6e61.11M ) \|\| (1.11M c >= 0x6ee1.11M && c <= 0x6ef1.11M )
30	1.11M	\|\| (1.11M c >= 0x6fa1.11M && c <= 0x6fc1.11M ) \|\| c == 0x6ff1.11M \|\| c == 0x7101.11M \|\| (1.11M c >= 0x7121.11M && c <= 0x72f1.11M )
31	1.11M	\|\| (1.11M c >= 0x74d1.11M && c <= 0x7a51.11M ) \|\| c == 0x7b11.11M \|\| (1.11M c >= 0x7ca1.11M && c <= 0x7ea1.11M ) \|\| (1.11M c >= 0x7f41.11M && c <= 0x7f51.11M )
32	1.11M	\|\| c == 0x7fa1.11M \|\| (1.11M c >= 0x8001.11M && c <= 0x8151.11M ) \|\| c == 0x81a1.11M \|\| c == 0x8241.11M
33	1.11M	\|\| c == 0x8281.11M \|\| (1.11M c >= 0x8401.11M && c <= 0x8581.11M ) \|\| (1.11M c >= 0x8601.11M && c <= 0x86a1.11M ) \|\| (1.11M c >= 0x8a01.11M && c <= 0x8b41.11M )
34	1.11M	\|\| (1.11M c >= 0x8b61.11M && c <= 0x8bd1.11M ) \|\| (1.11M c >= 0x9041.11M && c <= 0x9391.11M ) \|\| c == 0x93d1.11M \|\| c == 0x9501.11M
35	1.11M	\|\| (1.11M c >= 0x9581.11M && c <= 0x9611.11M ) \|\| (1.11M c >= 0x9711.11M && c <= 0x9801.11M ) \|\| (1.11M c >= 0x9851.11M && c <= 0x98c1.11M ) \|\| (1.11M c >= 0x98f1.11M && c <= 0x9901.11M )
36	1.11M	\|\| (1.11M c >= 0x9931.11M && c <= 0x9a81.11M ) \|\| (1.11M c >= 0x9aa1.11M && c <= 0x9b01.11M ) \|\| c == 0x9b21.11M \|\| (1.11M c >= 0x9b61.11M && c <= 0x9b91.11M )
37	1.11M	\|\| c == 0x9bd1.11M \|\| c == 0x9ce1.11M \|\| (1.11M c >= 0x9dc1.11M && c <= 0x9dd1.11M ) \|\| (1.11M c >= 0x9df1.11M && c <= 0x9e11.11M )
38	1.11M	\|\| (1.11M c >= 0x9f01.11M && c <= 0x9f11.11M ) \|\| c == 0x9fc1.11M \|\| (1.11M c >= 0xa051.11M && c <= 0xa0a1.11M ) \|\| (1.11M c >= 0xa0f1.11M && c <= 0xa101.11M )
39	1.11M	\|\| (1.11M c >= 0xa131.11M && c <= 0xa281.11M ) \|\| (1.11M c >= 0xa2a1.11M && c <= 0xa301.11M ) \|\| (1.11M c >= 0xa321.11M && c <= 0xa331.11M ) \|\| (1.11M c >= 0xa351.11M && c <= 0xa361.11M )
40	1.11M	\|\| (1.11M c >= 0xa381.11M && c <= 0xa391.11M ) \|\| (1.11M c >= 0xa591.11M && c <= 0xa5c1.11M ) \|\| c == 0xa5e1.11M \|\| (1.11M c >= 0xa721.11M && c <= 0xa741.11M )
41	1.11M	\|\| (1.11M c >= 0xa851.11M && c <= 0xa8d1.11M ) \|\| (1.11M c >= 0xa8f1.11M && c <= 0xa911.11M ) \|\| (1.11M c >= 0xa931.11M && c <= 0xaa81.11M ) \|\| (1.11M c >= 0xaaa1.11M && c <= 0xab01.11M )
42	1.11M	\|\| (1.11M c >= 0xab21.11M && c <= 0xab31.11M ) \|\| (1.11M c >= 0xab51.11M && c <= 0xab91.11M ) \|\| c == 0xabd1.11M \|\| c == 0xad01.11M
43	1.11M	\|\| (1.11M c >= 0xae01.11M && c <= 0xae11.11M ) \|\| c == 0xaf91.11M \|\| (1.11M c >= 0xb051.11M && c <= 0xb0c1.11M ) \|\| (1.11M c >= 0xb0f1.11M && c <= 0xb101.11M )
44	1.11M	\|\| (1.11M c >= 0xb131.11M && c <= 0xb281.11M ) \|\| (1.11M c >= 0xb2a1.11M && c <= 0xb301.11M ) \|\| (1.11M c >= 0xb321.11M && c <= 0xb331.11M ) \|\| (1.11M c >= 0xb351.11M && c <= 0xb391.11M )
45	1.11M	\|\| c == 0xb3d1.11M \|\| (1.11M c >= 0xb5c1.11M && c <= 0xb5d1.11M ) \|\| (1.11M c >= 0xb5f1.11M && c <= 0xb611.11M ) \|\| c == 0xb711.11M
46	1.11M	\|\| c == 0xb831.11M \|\| (1.11M c >= 0xb851.11M && c <= 0xb8a1.11M ) \|\| (1.11M c >= 0xb8e1.11M && c <= 0xb901.11M ) \|\| (1.11M c >= 0xb921.11M && c <= 0xb951.11M )
47	1.11M	\|\| (1.11M c >= 0xb991.11M && c <= 0xb9a1.11M ) \|\| c == 0xb9c1.11M \|\| (1.11M c >= 0xb9e1.11M && c <= 0xb9f1.11M ) \|\| (1.11M c >= 0xba31.11M && c <= 0xba41.11M )
48	1.11M	\|\| (1.11M c >= 0xba81.11M && c <= 0xbaa1.11M ) \|\| (1.11M c >= 0xbae1.11M && c <= 0xbb91.11M ) \|\| c == 0xbd01.11M \|\| (1.11M c >= 0xc051.11M && c <= 0xc0c1.11M )
49	1.11M	\|\| (1.11M c >= 0xc0e1.11M && c <= 0xc101.11M ) \|\| (1.11M c >= 0xc121.11M && c <= 0xc281.11M ) \|\| (1.11M c >= 0xc2a1.11M && c <= 0xc391.11M ) \|\| c == 0xc3d1.11M
50	1.11M	\|\| (1.11M c >= 0xc581.11M && c <= 0xc5a1.11M ) \|\| (1.11M c >= 0xc601.11M && c <= 0xc611.11M ) \|\| c == 0xc801.11M \|\| (1.11M c >= 0xc851.11M && c <= 0xc8c1.11M )
51	1.11M	\|\| (1.11M c >= 0xc8e1.11M && c <= 0xc901.11M ) \|\| (1.11M c >= 0xc921.11M && c <= 0xca81.11M ) \|\| (1.11M c >= 0xcaa1.11M && c <= 0xcb31.11M ) \|\| (1.11M c >= 0xcb51.11M && c <= 0xcb91.11M )
52	1.11M	\|\| c == 0xcbd1.11M \|\| c == 0xcde1.11M \|\| (1.11M c >= 0xce01.11M && c <= 0xce11.11M ) \|\| (1.11M c >= 0xcf11.11M && c <= 0xcf21.11M )
53	1.11M	\|\| (1.11M c >= 0xd051.11M && c <= 0xd0c1.11M ) \|\| (1.11M c >= 0xd0e1.11M && c <= 0xd101.11M ) \|\| (1.11M c >= 0xd121.11M && c <= 0xd3a1.11M ) \|\| c == 0xd3d1.11M
54	1.11M	\|\| c == 0xd4e1.11M \|\| (1.11M c >= 0xd541.11M && c <= 0xd561.11M ) \|\| (1.11M c >= 0xd5f1.11M && c <= 0xd611.11M ) \|\| (1.11M c >= 0xd7a1.11M && c <= 0xd7f1.11M )
55	1.11M	\|\| (1.11M c >= 0xd851.11M && c <= 0xd961.11M ) \|\| (1.11M c >= 0xd9a1.11M && c <= 0xdb11.11M ) \|\| (1.11M c >= 0xdb31.11M && c <= 0xdbb1.11M ) \|\| c == 0xdbd1.11M
56	1.11M	\|\| (1.11M c >= 0xdc01.11M && c <= 0xdc61.11M ) \|\| (1.11M c >= 0xe011.11M && c <= 0xe301.11M ) \|\| (1.11M c >= 0xe321.11M && c <= 0xe331.11M ) \|\| (1.11M c >= 0xe401.11M && c <= 0xe461.11M )
57	1.11M	\|\| (1.11M c >= 0xe811.11M && c <= 0xe821.11M ) \|\| c == 0xe841.11M \|\| (1.11M c >= 0xe871.11M && c <= 0xe881.11M ) \|\| c == 0xe8a1.11M
58	1.11M	\|\| c == 0xe8d1.11M \|\| (1.11M c >= 0xe941.11M && c <= 0xe971.11M ) \|\| (1.11M c >= 0xe991.11M && c <= 0xe9f1.11M ) \|\| (1.11M c >= 0xea11.11M && c <= 0xea31.11M )
59	1.11M	\|\| c == 0xea51.11M \|\| c == 0xea71.11M \|\| (1.11M c >= 0xeaa1.11M && c <= 0xeab1.11M ) \|\| (1.11M c >= 0xead1.11M && c <= 0xeb01.11M )
60	1.11M	\|\| (1.11M c >= 0xeb21.11M && c <= 0xeb31.11M ) \|\| c == 0xebd1.11M \|\| (1.11M c >= 0xec01.11M && c <= 0xec41.11M ) \|\| c == 0xec61.11M
61	1.11M	\|\| (1.11M c >= 0xedc1.11M && c <= 0xedf1.11M ) \|\| c == 0xf001.11M \|\| (1.11M c >= 0xf401.11M && c <= 0xf471.11M ) \|\| (1.11M c >= 0xf491.11M && c <= 0xf6c1.11M )
62	1.11M	\|\| (1.11M c >= 0xf881.11M && c <= 0xf8c1.11M ) \|\| (1.11M c >= 0x10001.11M && c <= 0x102a1.11M ) \|\| c == 0x103f1.11M \|\| (1.11M c >= 0x10501.11M && c <= 0x10551.10M )
63	1.11M	\|\| (1.11M c >= 0x105a1.11M && c <= 0x105d1.10M ) \|\| c == 0x10611.11M \|\| (1.11M c >= 0x10651.11M && c <= 0x10661.10M ) \|\| (1.11M c >= 0x106e1.11M && c <= 0x10701.10M )
64	1.11M	\|\| (1.11M c >= 0x10751.11M && c <= 0x10811.10M ) \|\| c == 0x108e1.11M \|\| (1.11M c >= 0x10a01.11M && c <= 0x10c51.10M ) \|\| c == 0x10c71.11M
65	1.11M	\|\| c == 0x10cd1.11M \|\| (1.11M c >= 0x10d01.11M && c <= 0x10fa1.10M ) \|\| (1.11M c >= 0x10fc1.11M && c <= 0x12481.10M ) \|\| (1.11M c >= 0x124a1.11M && c <= 0x124d1.10M )
66	1.11M	\|\| (1.11M c >= 0x12501.11M && c <= 0x12561.10M ) \|\| c == 0x12581.11M \|\| (1.11M c >= 0x125a1.11M && c <= 0x125d1.10M ) \|\| (1.11M c >= 0x12601.11M && c <= 0x12881.10M )
67	1.11M	\|\| (1.11M c >= 0x128a1.11M && c <= 0x128d1.10M ) \|\| (1.11M c >= 0x12901.11M && c <= 0x12b01.10M ) \|\| (1.11M c >= 0x12b21.11M && c <= 0x12b51.10M ) \|\| (1.11M c >= 0x12b81.11M && c <= 0x12be1.10M )
68	1.11M	\|\| c == 0x12c01.11M \|\| (1.11M c >= 0x12c21.11M && c <= 0x12c51.10M ) \|\| (1.11M c >= 0x12c81.11M && c <= 0x12d61.10M ) \|\| (1.11M c >= 0x12d81.11M && c <= 0x13101.10M )
69	1.11M	\|\| (1.11M c >= 0x13121.11M && c <= 0x13151.10M ) \|\| (1.11M c >= 0x13181.11M && c <= 0x135a1.10M ) \|\| (1.11M c >= 0x13801.11M && c <= 0x138f1.10M ) \|\| (1.11M c >= 0x13a01.11M && c <= 0x13f51.10M )
70	1.11M	\|\| (1.11M c >= 0x13f81.11M && c <= 0x13fd1.10M ) \|\| (1.11M c >= 0x14011.11M && c <= 0x166c1.10M ) \|\| (1.11M c >= 0x166f1.11M && c <= 0x167f1.10M ) \|\| (1.11M c >= 0x16811.11M && c <= 0x169a1.10M )
71	1.11M	\|\| (1.11M c >= 0x16a01.11M && c <= 0x16ea1.10M ) \|\| (1.11M c >= 0x16ee1.11M && c <= 0x16f81.10M ) \|\| (1.11M c >= 0x17001.11M && c <= 0x170c1.10M ) \|\| (1.11M c >= 0x170e1.11M && c <= 0x17111.10M )
72	1.11M	\|\| (1.11M c >= 0x17201.11M && c <= 0x17311.10M ) \|\| (1.11M c >= 0x17401.11M && c <= 0x17511.10M ) \|\| (1.11M c >= 0x17601.11M && c <= 0x176c1.10M ) \|\| (1.11M c >= 0x176e1.11M && c <= 0x17701.10M )
73	1.11M	\|\| (1.11M c >= 0x17801.11M && c <= 0x17b31.10M ) \|\| c == 0x17d71.11M \|\| c == 0x17dc1.11M \|\| (1.11M c >= 0x18201.11M && c <= 0x18771.10M )
74	1.11M	\|\| (1.11M c >= 0x18801.11M && c <= 0x18841.10M ) \|\| (1.11M c >= 0x18871.11M && c <= 0x18a81.10M ) \|\| c == 0x18aa1.11M \|\| (1.11M c >= 0x18b01.11M && c <= 0x18f51.10M )
75	1.11M	\|\| (1.10M c >= 0x19001.10M && c <= 0x191e1.10M ) \|\| (1.10M c >= 0x19501.10M && c <= 0x196d1.10M ) \|\| (1.10M c >= 0x19701.10M && c <= 0x19741.10M ) \|\| (1.10M c >= 0x19801.10M && c <= 0x19ab1.10M )
76	1.11M	\|\| (1.10M c >= 0x19b01.10M && c <= 0x19c91.10M ) \|\| (1.10M c >= 0x1a001.10M && c <= 0x1a161.10M ) \|\| (1.10M c >= 0x1a201.10M && c <= 0x1a541.10M ) \|\| c == 0x1aa71.10M
77	1.11M	\|\| (1.10M c >= 0x1b051.10M && c <= 0x1b331.10M ) \|\| (1.10M c >= 0x1b451.10M && c <= 0x1b4b1.10M ) \|\| (1.10M c >= 0x1b831.10M && c <= 0x1ba01.10M ) \|\| (1.10M c >= 0x1bae1.10M && c <= 0x1baf1.10M )
78	1.11M	\|\| (1.10M c >= 0x1bba1.10M && c <= 0x1be51.10M ) \|\| (1.10M c >= 0x1c001.10M && c <= 0x1c231.10M ) \|\| (1.10M c >= 0x1c4d1.10M && c <= 0x1c4f1.10M ) \|\| (1.10M c >= 0x1c5a1.10M && c <= 0x1c7d1.10M )
79	1.11M	\|\| (1.10M c >= 0x1c801.10M && c <= 0x1c881.10M ) \|\| (1.10M c >= 0x1ce91.10M && c <= 0x1cec1.10M ) \|\| (1.10M c >= 0x1cee1.10M && c <= 0x1cf11.10M ) \|\| (1.10M c >= 0x1cf51.10M && c <= 0x1cf61.10M )
80	1.11M	\|\| (1.10M c >= 0x1d001.10M && c <= 0x1dbf1.10M ) \|\| (1.10M c >= 0x1e001.10M && c <= 0x1f151.10M ) \|\| (1.10M c >= 0x1f181.10M && c <= 0x1f1d1.10M ) \|\| (1.10M c >= 0x1f201.10M && c <= 0x1f451.10M )
81	1.11M	\|\| (1.10M c >= 0x1f481.10M && c <= 0x1f4d1.10M ) \|\| (1.10M c >= 0x1f501.10M && c <= 0x1f571.10M ) \|\| c == 0x1f591.10M \|\| c == 0x1f5b1.10M
82	1.11M	\|\| c == 0x1f5d1.10M \|\| (1.10M c >= 0x1f5f1.10M && c <= 0x1f7d1.10M ) \|\| (1.10M c >= 0x1f801.10M && c <= 0x1fb41.10M ) \|\| (1.10M c >= 0x1fb61.10M && c <= 0x1fbc1.10M )
83	1.11M	\|\| c == 0x1fbe1.10M \|\| (1.10M c >= 0x1fc21.10M && c <= 0x1fc41.10M ) \|\| (1.10M c >= 0x1fc61.10M && c <= 0x1fcc1.10M ) \|\| (1.10M c >= 0x1fd01.10M && c <= 0x1fd31.10M )
84	1.11M	\|\| (1.10M c >= 0x1fd61.10M && c <= 0x1fdb1.10M ) \|\| (1.10M c >= 0x1fe01.10M && c <= 0x1fec1.10M ) \|\| (1.10M c >= 0x1ff21.10M && c <= 0x1ff41.10M ) \|\| (1.10M c >= 0x1ff61.10M && c <= 0x1ffc1.10M )
85	1.11M	\|\| c == 0x20711.10M \|\| c == 0x207f1.10M \|\| (1.10M c >= 0x20901.10M && c <= 0x209c1.10M ) \|\| c == 0x21021.10M
86	1.11M	\|\| c == 0x21071.10M \|\| (1.10M c >= 0x210a1.10M && c <= 0x21131.10M ) \|\| c == 0x21151.10M \|\| (1.10M c >= 0x21191.10M && c <= 0x211d1.10M )
87	1.11M	\|\| c == 0x21241.10M \|\| c == 0x21261.10M \|\| c == 0x21281.10M \|\| (1.10M c >= 0x212a1.10M && c <= 0x212d1.10M )
88	1.11M	\|\| (1.10M c >= 0x212f1.10M && c <= 0x21391.10M ) \|\| (1.10M c >= 0x213c1.10M && c <= 0x213f1.10M ) \|\| (1.10M c >= 0x21451.10M && c <= 0x21491.10M ) \|\| c == 0x214e1.10M
89	1.11M	\|\| (1.10M c >= 0x21601.10M && c <= 0x21881.10M ) \|\| (1.10M c >= 0x2c001.10M && c <= 0x2c2e1.10M ) \|\| (1.10M c >= 0x2c301.10M && c <= 0x2c5e1.10M ) \|\| (1.10M c >= 0x2c601.10M && c <= 0x2ce41.10M )
90	1.11M	\|\| (1.10M c >= 0x2ceb1.10M && c <= 0x2cee1.10M ) \|\| (1.10M c >= 0x2cf21.10M && c <= 0x2cf31.10M ) \|\| (1.10M c >= 0x2d001.10M && c <= 0x2d251.10M ) \|\| c == 0x2d271.10M
91	1.11M	\|\| c == 0x2d2d1.10M \|\| (1.10M c >= 0x2d301.10M && c <= 0x2d671.10M ) \|\| c == 0x2d6f1.10M \|\| (1.10M c >= 0x2d801.10M && c <= 0x2d961.10M )
92	1.11M	\|\| (1.10M c >= 0x2da01.10M && c <= 0x2da61.10M ) \|\| (1.10M c >= 0x2da81.10M && c <= 0x2dae1.10M ) \|\| (1.10M c >= 0x2db01.10M && c <= 0x2db61.10M ) \|\| (1.10M c >= 0x2db81.10M && c <= 0x2dbe1.10M )
93	1.11M	\|\| (1.10M c >= 0x2dc01.10M && c <= 0x2dc61.10M ) \|\| (1.10M c >= 0x2dc81.10M && c <= 0x2dce1.10M ) \|\| (1.10M c >= 0x2dd01.10M && c <= 0x2dd61.10M ) \|\| (1.10M c >= 0x2dd81.10M && c <= 0x2dde1.10M )
94	1.11M	\|\| c == 0x2e2f1.10M \|\| (1.10M c >= 0x30051.10M && c <= 0x30071.10M ) \|\| (1.10M c >= 0x30211.10M && c <= 0x30291.10M ) \|\| (1.10M c >= 0x30311.10M && c <= 0x30351.10M )
95	1.11M	\|\| (1.10M c >= 0x30381.10M && c <= 0x303c1.10M ) \|\| (1.10M c >= 0x30411.10M && c <= 0x30961.10M ) \|\| (1.10M c >= 0x309d1.10M && c <= 0x309f1.10M ) \|\| (1.10M c >= 0x30a11.10M && c <= 0x30fa1.10M )
96	1.11M	\|\| (1.10M c >= 0x30fc1.10M && c <= 0x30ff1.10M ) \|\| (1.10M c >= 0x31051.10M && c <= 0x312e1.10M ) \|\| (1.10M c >= 0x31311.10M && c <= 0x318e1.10M ) \|\| (1.10M c >= 0x31a01.10M && c <= 0x31ba1.10M )
97	1.11M	\|\| (1.10M c >= 0x31f01.10M && c <= 0x31ff1.10M ) \|\| (1.10M c >= 0x34001.10M && c <= 0x4db51.10M ) \|\| (1.10M c >= 0x4e001.10M && c <= 0x9fea1.09M ) \|\| (1.08M c >= 0xa0001.08M && c <= 0xa48c1.07M )
98	1.11M	\|\| (1.07M c >= 0xa4d01.07M && c <= 0xa4fd1.07M ) \|\| (1.07M c >= 0xa5001.07M && c <= 0xa60c1.07M ) \|\| (1.07M c >= 0xa6101.07M && c <= 0xa61f1.07M ) \|\| (1.07M c >= 0xa62a1.07M && c <= 0xa62b1.07M )
99	1.11M	\|\| (1.07M c >= 0xa6401.07M && c <= 0xa66e1.07M ) \|\| (1.07M c >= 0xa67f1.07M && c <= 0xa69d1.07M ) \|\| (1.07M c >= 0xa6a01.07M && c <= 0xa6ef1.07M ) \|\| (1.07M c >= 0xa7171.07M && c <= 0xa71f1.07M )
100	1.11M	\|\| (1.07M c >= 0xa7221.07M && c <= 0xa7881.07M ) \|\| (1.07M c >= 0xa78b1.07M && c <= 0xa7ae1.07M ) \|\| (1.07M c >= 0xa7b01.07M && c <= 0xa7b71.07M ) \|\| (1.07M c >= 0xa7f71.07M && c <= 0xa8011.07M )
101	1.11M	\|\| (1.07M c >= 0xa8031.07M && c <= 0xa8051.07M ) \|\| (1.07M c >= 0xa8071.07M && c <= 0xa80a1.07M ) \|\| (1.07M c >= 0xa80c1.07M && c <= 0xa8221.07M ) \|\| (1.07M c >= 0xa8401.07M && c <= 0xa8731.07M )
102	1.11M	\|\| (1.07M c >= 0xa8821.07M && c <= 0xa8b31.07M ) \|\| (1.07M c >= 0xa8f21.07M && c <= 0xa8f71.07M ) \|\| c == 0xa8fb1.07M \|\| c == 0xa8fd1.07M
103	1.11M	\|\| (1.07M c >= 0xa90a1.07M && c <= 0xa9251.07M ) \|\| (1.07M c >= 0xa9301.07M && c <= 0xa9461.07M ) \|\| (1.07M c >= 0xa9601.07M && c <= 0xa97c1.07M ) \|\| (1.07M c >= 0xa9841.07M && c <= 0xa9b21.07M )
104	1.11M	\|\| c == 0xa9cf1.07M \|\| (1.07M c >= 0xa9e01.07M && c <= 0xa9e41.07M ) \|\| (1.07M c >= 0xa9e61.07M && c <= 0xa9ef1.07M ) \|\| (1.07M c >= 0xa9fa1.07M && c <= 0xa9fe1.07M )
105	1.11M	\|\| (1.07M c >= 0xaa001.07M && c <= 0xaa281.07M ) \|\| (1.07M c >= 0xaa401.07M && c <= 0xaa421.07M ) \|\| (1.07M c >= 0xaa441.07M && c <= 0xaa4b1.07M ) \|\| (1.07M c >= 0xaa601.07M && c <= 0xaa761.07M )
106	1.11M	\|\| c == 0xaa7a1.07M \|\| (1.07M c >= 0xaa7e1.07M && c <= 0xaaaf1.07M ) \|\| c == 0xaab11.07M \|\| (1.07M c >= 0xaab51.07M && c <= 0xaab61.07M )
107	1.11M	\|\| (1.07M c >= 0xaab91.07M && c <= 0xaabd1.07M ) \|\| c == 0xaac01.07M \|\| c == 0xaac21.07M \|\| (1.07M c >= 0xaadb1.07M && c <= 0xaadd1.07M )
108	1.11M	\|\| (1.07M c >= 0xaae01.07M && c <= 0xaaea1.07M ) \|\| (1.07M c >= 0xaaf21.07M && c <= 0xaaf41.07M ) \|\| (1.07M c >= 0xab011.07M && c <= 0xab061.07M ) \|\| (1.07M c >= 0xab091.07M && c <= 0xab0e1.07M )
109	1.11M	\|\| (1.07M c >= 0xab111.07M && c <= 0xab161.07M ) \|\| (1.07M c >= 0xab201.07M && c <= 0xab261.07M ) \|\| (1.07M c >= 0xab281.07M && c <= 0xab2e1.07M ) \|\| (1.07M c >= 0xab301.07M && c <= 0xab5a1.07M )
110	1.11M	\|\| (1.07M c >= 0xab5c1.07M && c <= 0xab651.07M ) \|\| (1.07M c >= 0xab701.07M && c <= 0xabe21.07M ) \|\| (1.07M c >= 0xac001.07M && c <= 0xd7a31.07M ) \|\| (1.06M c >= 0xd7b01.06M && c <= 0xd7c61.05M )
111	1.11M	\|\| (1.06M c >= 0xd7cb1.06M && c <= 0xd7fb1.05M ) \|\| (1.06M c >= 0xf9001.06M && c <= 0xfa6d1.05M ) \|\| (1.06M c >= 0xfa701.06M && c <= 0xfad91.05M ) \|\| (1.06M c >= 0xfb001.06M && c <= 0xfb061.04M )
112	1.11M	\|\| (1.06M c >= 0xfb131.06M && c <= 0xfb171.04M ) \|\| c == 0xfb1d1.06M \|\| (1.06M c >= 0xfb1f1.06M && c <= 0xfb281.04M ) \|\| (1.06M c >= 0xfb2a1.06M && c <= 0xfb361.04M )
113	1.11M	\|\| (1.06M c >= 0xfb381.06M && c <= 0xfb3c1.04M ) \|\| c == 0xfb3e1.06M \|\| (1.06M c >= 0xfb401.06M && c <= 0xfb411.04M ) \|\| (1.06M c >= 0xfb431.06M && c <= 0xfb441.04M )
114	1.11M	\|\| (1.06M c >= 0xfb461.06M && c <= 0xfbb11.04M ) \|\| (1.06M c >= 0xfbd31.06M && c <= 0xfd3d1.04M ) \|\| (1.06M c >= 0xfd501.06M && c <= 0xfd8f1.04M ) \|\| (1.06M c >= 0xfd921.06M && c <= 0xfdc71.04M )
115	1.11M	\|\| (1.06M c >= 0xfdf01.06M && c <= 0xfdfb1.04M ) \|\| (1.06M c >= 0xfe701.06M && c <= 0xfe741.04M ) \|\| (1.06M c >= 0xfe761.06M && c <= 0xfefc1.04M ) \|\| (1.06M c >= 0xff211.06M && c <= 0xff3a1.04M )
116	1.11M	\|\| (1.06M c >= 0xff411.06M && c <= 0xff5a1.04M ) \|\| (1.06M c >= 0xff661.06M && c <= 0xffbe1.04M ) \|\| (1.06M c >= 0xffc21.06M && c <= 0xffc71.04M ) \|\| (1.06M c >= 0xffca1.06M && c <= 0xffcf1.04M )
117	1.11M	\|\| (1.06M c >= 0xffd21.06M && c <= 0xffd71.04M ) \|\| (1.06M c >= 0xffda1.06M && c <= 0xffdc1.04M ) \|\| (1.06M c >= 0x100001.06M && c <= 0x1000b1.04M ) \|\| (1.06M c >= 0x1000d1.06M && c <= 0x100261.04M )
118	1.11M	\|\| (1.06M c >= 0x100281.06M && c <= 0x1003a1.04M ) \|\| (1.06M c >= 0x1003c1.06M && c <= 0x1003d1.04M ) \|\| (1.06M c >= 0x1003f1.06M && c <= 0x1004d1.04M ) \|\| (1.06M c >= 0x100501.06M && c <= 0x1005d1.04M )
119	1.11M	\|\| (1.06M c >= 0x100801.06M && c <= 0x100fa1.04M ) \|\| (1.06M c >= 0x101401.06M && c <= 0x101741.04M ) \|\| (1.06M c >= 0x102801.06M && c <= 0x1029c1.04M ) \|\| (1.06M c >= 0x102a01.06M && c <= 0x102d01.04M )
120	1.11M	\|\| (1.06M c >= 0x103001.06M && c <= 0x1031f1.04M ) \|\| (1.06M c >= 0x1032d1.06M && c <= 0x1034a1.04M ) \|\| (1.06M c >= 0x103501.06M && c <= 0x103751.04M ) \|\| (1.06M c >= 0x103801.06M && c <= 0x1039d1.04M )
121	1.11M	\|\| (1.06M c >= 0x103a01.06M && c <= 0x103c31.04M ) \|\| (1.06M c >= 0x103c81.06M && c <= 0x103cf1.04M ) \|\| (1.06M c >= 0x103d11.06M && c <= 0x103d51.04M ) \|\| (1.06M c >= 0x104001.06M && c <= 0x1049d1.04M )
122	1.11M	\|\| (1.06M c >= 0x104b01.06M && c <= 0x104d31.04M ) \|\| (1.06M c >= 0x104d81.06M && c <= 0x104fb1.04M ) \|\| (1.06M c >= 0x105001.06M && c <= 0x105271.04M ) \|\| (1.06M c >= 0x105301.06M && c <= 0x105631.04M )
123	1.11M	\|\| (1.06M c >= 0x106001.06M && c <= 0x107361.04M ) \|\| (1.06M c >= 0x107401.06M && c <= 0x107551.04M ) \|\| (1.06M c >= 0x107601.06M && c <= 0x107671.04M ) \|\| (1.06M c >= 0x108001.06M && c <= 0x108051.04M )
124	1.11M	\|\| c == 0x108081.06M \|\| (1.06M c >= 0x1080a1.06M && c <= 0x108351.04M ) \|\| (1.06M c >= 0x108371.06M && c <= 0x108381.04M ) \|\| c == 0x1083c1.06M
125	1.11M	\|\| (1.06M c >= 0x1083f1.06M && c <= 0x108551.04M ) \|\| (1.06M c >= 0x108601.06M && c <= 0x108761.04M ) \|\| (1.06M c >= 0x108801.06M && c <= 0x1089e1.04M ) \|\| (1.06M c >= 0x108e01.06M && c <= 0x108f21.04M )
126	1.11M	\|\| (1.06M c >= 0x108f41.06M && c <= 0x108f51.04M ) \|\| (1.06M c >= 0x109001.06M && c <= 0x109151.04M ) \|\| (1.06M c >= 0x109201.06M && c <= 0x109391.04M ) \|\| (1.06M c >= 0x109801.06M && c <= 0x109b71.04M )
127	1.11M	\|\| (1.06M c >= 0x109be1.06M && c <= 0x109bf1.04M ) \|\| c == 0x10a001.06M \|\| (1.06M c >= 0x10a101.06M && c <= 0x10a131.04M ) \|\| (1.06M c >= 0x10a151.06M && c <= 0x10a171.04M )
128	1.11M	\|\| (1.06M c >= 0x10a191.06M && c <= 0x10a331.04M ) \|\| (1.06M c >= 0x10a601.06M && c <= 0x10a7c1.04M ) \|\| (1.06M c >= 0x10a801.06M && c <= 0x10a9c1.04M ) \|\| (1.06M c >= 0x10ac01.06M && c <= 0x10ac71.04M )
129	1.11M	\|\| (1.06M c >= 0x10ac91.06M && c <= 0x10ae41.04M ) \|\| (1.06M c >= 0x10b001.06M && c <= 0x10b351.04M ) \|\| (1.06M c >= 0x10b401.06M && c <= 0x10b551.04M ) \|\| (1.06M c >= 0x10b601.06M && c <= 0x10b721.04M )
130	1.11M	\|\| (1.06M c >= 0x10b801.06M && c <= 0x10b911.04M ) \|\| (1.06M c >= 0x10c001.06M && c <= 0x10c481.04M ) \|\| (1.06M c >= 0x10c801.06M && c <= 0x10cb21.04M ) \|\| (1.06M c >= 0x10cc01.06M && c <= 0x10cf21.04M )
131	1.11M	\|\| (1.06M c >= 0x110031.06M && c <= 0x110371.04M ) \|\| (1.06M c >= 0x110831.06M && c <= 0x110af1.04M ) \|\| (1.06M c >= 0x110d01.06M && c <= 0x110e81.04M ) \|\| (1.06M c >= 0x111031.06M && c <= 0x111261.04M )
132	1.11M	\|\| (1.06M c >= 0x111501.06M && c <= 0x111721.04M ) \|\| c == 0x111761.06M \|\| (1.06M c >= 0x111831.06M && c <= 0x111b21.04M ) \|\| (1.06M c >= 0x111c11.06M && c <= 0x111c41.04M )
133	1.11M	\|\| c == 0x111da1.06M \|\| c == 0x111dc1.06M \|\| (1.06M c >= 0x112001.06M && c <= 0x112111.04M ) \|\| (1.06M c >= 0x112131.06M && c <= 0x1122b1.04M )
134	1.11M	\|\| (1.06M c >= 0x112801.06M && c <= 0x112861.04M ) \|\| c == 0x112881.06M \|\| (1.06M c >= 0x1128a1.06M && c <= 0x1128d1.04M ) \|\| (1.06M c >= 0x1128f1.06M && c <= 0x1129d1.04M )
135	1.11M	\|\| (1.06M c >= 0x1129f1.06M && c <= 0x112a81.04M ) \|\| (1.06M c >= 0x112b01.06M && c <= 0x112de1.04M ) \|\| (1.06M c >= 0x113051.06M && c <= 0x1130c1.04M ) \|\| (1.06M c >= 0x1130f1.06M && c <= 0x113101.04M )
136	1.11M	\|\| (1.06M c >= 0x113131.06M && c <= 0x113281.04M ) \|\| (1.06M c >= 0x1132a1.06M && c <= 0x113301.04M ) \|\| (1.06M c >= 0x113321.06M && c <= 0x113331.04M ) \|\| (1.06M c >= 0x113351.06M && c <= 0x113391.04M )
137	1.11M	\|\| c == 0x1133d1.06M \|\| c == 0x113501.06M \|\| (1.06M c >= 0x1135d1.06M && c <= 0x113611.04M ) \|\| (1.06M c >= 0x114001.06M && c <= 0x114341.04M )
138	1.11M	\|\| (1.06M c >= 0x114471.06M && c <= 0x1144a1.04M ) \|\| (1.06M c >= 0x114801.06M && c <= 0x114af1.04M ) \|\| (1.06M c >= 0x114c41.06M && c <= 0x114c51.04M ) \|\| c == 0x114c71.06M
139	1.11M	\|\| (1.06M c >= 0x115801.06M && c <= 0x115ae1.04M ) \|\| (1.06M c >= 0x115d81.06M && c <= 0x115db1.04M ) \|\| (1.06M c >= 0x116001.06M && c <= 0x1162f1.04M ) \|\| c == 0x116441.06M
140	1.11M	\|\| (1.06M c >= 0x116801.06M && c <= 0x116aa1.04M ) \|\| (1.06M c >= 0x117001.06M && c <= 0x117191.04M ) \|\| (1.06M c >= 0x118a01.06M && c <= 0x118df1.04M ) \|\| c == 0x118ff1.06M
141	1.11M	\|\| c == 0x11a001.06M \|\| (1.06M c >= 0x11a0b1.06M && c <= 0x11a321.04M ) \|\| c == 0x11a3a1.06M \|\| c == 0x11a501.06M
142	1.11M	\|\| (1.06M c >= 0x11a5c1.06M && c <= 0x11a831.04M ) \|\| (1.06M c >= 0x11a861.06M && c <= 0x11a891.04M ) \|\| (1.06M c >= 0x11ac01.06M && c <= 0x11af81.04M ) \|\| (1.06M c >= 0x11c001.06M && c <= 0x11c081.04M )
143	1.11M	\|\| (1.06M c >= 0x11c0a1.06M && c <= 0x11c2e1.04M ) \|\| c == 0x11c401.06M \|\| (1.06M c >= 0x11c721.06M && c <= 0x11c8f1.04M ) \|\| (1.06M c >= 0x11d001.06M && c <= 0x11d061.04M )
144	1.11M	\|\| (1.06M c >= 0x11d081.06M && c <= 0x11d091.04M ) \|\| (1.06M c >= 0x11d0b1.06M && c <= 0x11d301.04M ) \|\| c == 0x11d461.06M \|\| (1.06M c >= 0x120001.06M && c <= 0x123991.04M )
145	1.11M	\|\| (1.06M c >= 0x124001.06M && c <= 0x1246e1.03M ) \|\| (1.06M c >= 0x124801.06M && c <= 0x125431.03M ) \|\| (1.06M c >= 0x130001.06M && c <= 0x1342e1.03M ) \|\| (1.06M c >= 0x144001.06M && c <= 0x146461.03M )
146	1.11M	\|\| (1.05M c >= 0x168001.05M && c <= 0x16a381.02M ) \|\| (1.05M c >= 0x16a401.05M && c <= 0x16a5e1.02M ) \|\| (1.05M c >= 0x16ad01.05M && c <= 0x16aed1.02M ) \|\| (1.05M c >= 0x16b001.05M && c <= 0x16b2f1.02M )
147	1.11M	\|\| (1.05M c >= 0x16b401.05M && c <= 0x16b431.02M ) \|\| (1.05M c >= 0x16b631.05M && c <= 0x16b771.02M ) \|\| (1.05M c >= 0x16b7d1.05M && c <= 0x16b8f1.02M ) \|\| (1.05M c >= 0x16f001.05M && c <= 0x16f441.02M )
148	1.11M	\|\| c == 0x16f501.05M \|\| (1.05M c >= 0x16f931.05M && c <= 0x16f9f1.02M ) \|\| (1.05M c >= 0x16fe01.05M && c <= 0x16fe11.01M ) \|\| (1.05M c >= 0x170001.05M && c <= 0x187ec1.01M )
149	1.11M	\|\| (1.05M c >= 0x188001.05M && c <= 0x18af21.01M ) \|\| (1.05M c >= 0x1b0001.05M && c <= 0x1b11e1.00M ) \|\| (1.05M c >= 0x1b1701.05M && c <= 0x1b2fb1.00M ) \|\| (1.05M c >= 0x1bc001.05M && c <= 0x1bc6a1.00M )
150	1.11M	\|\| (1.05M c >= 0x1bc701.05M && c <= 0x1bc7c1.00M ) \|\| (1.05M c >= 0x1bc801.05M && c <= 0x1bc881.00M ) \|\| (1.05M c >= 0x1bc901.05M && c <= 0x1bc991.00M ) \|\| (1.05M c >= 0x1d4001.05M && c <= 0x1d454994k )
151	1.11M	\|\| (1.05M c >= 0x1d4561.05M && c <= 0x1d49c994k ) \|\| (1.05M c >= 0x1d49e1.05M && c <= 0x1d49f994k ) \|\| c == 0x1d4a21.05M \|\| (1.05M c >= 0x1d4a51.05M && c <= 0x1d4a6994k )
152	1.11M	\|\| (1.05M c >= 0x1d4a91.05M && c <= 0x1d4ac994k ) \|\| (1.05M c >= 0x1d4ae1.05M && c <= 0x1d4b9994k ) \|\| c == 0x1d4bb1.05M \|\| (1.05M c >= 0x1d4bd1.05M && c <= 0x1d4c3994k )
153	1.11M	\|\| (1.05M c >= 0x1d4c51.05M && c <= 0x1d505994k ) \|\| (1.05M c >= 0x1d5071.05M && c <= 0x1d50a994k ) \|\| (1.05M c >= 0x1d50d1.05M && c <= 0x1d514994k ) \|\| (1.05M c >= 0x1d5161.05M && c <= 0x1d51c994k )
154	1.11M	\|\| (1.05M c >= 0x1d51e1.05M && c <= 0x1d539994k ) \|\| (1.05M c >= 0x1d53b1.05M && c <= 0x1d53e993k ) \|\| (1.05M c >= 0x1d5401.05M && c <= 0x1d544993k ) \|\| c == 0x1d5461.05M
155	1.11M	\|\| (1.05M c >= 0x1d54a1.05M && c <= 0x1d550993k ) \|\| (1.05M c >= 0x1d5521.05M && c <= 0x1d6a5993k ) \|\| (1.05M c >= 0x1d6a81.05M && c <= 0x1d6c0993k ) \|\| (1.05M c >= 0x1d6c21.05M && c <= 0x1d6da993k )
156	1.11M	\|\| (1.05M c >= 0x1d6dc1.05M && c <= 0x1d6fa993k ) \|\| (1.05M c >= 0x1d6fc1.05M && c <= 0x1d714993k ) \|\| (1.05M c >= 0x1d7161.05M && c <= 0x1d734993k ) \|\| (1.05M c >= 0x1d7361.05M && c <= 0x1d74e993k )
157	1.11M	\|\| (1.05M c >= 0x1d7501.05M && c <= 0x1d76e993k ) \|\| (1.05M c >= 0x1d7701.05M && c <= 0x1d788993k ) \|\| (1.05M c >= 0x1d78a1.05M && c <= 0x1d7a8993k ) \|\| (1.05M c >= 0x1d7aa1.05M && c <= 0x1d7c2993k )
158	1.11M	\|\| (1.05M c >= 0x1d7c41.05M && c <= 0x1d7cb993k ) \|\| (1.05M c >= 0x1e8001.05M && c <= 0x1e8c4989k ) \|\| (1.04M c >= 0x1e9001.04M && c <= 0x1e943988k ) \|\| (1.04M c >= 0x1ee001.04M && c <= 0x1ee03987k )
159	1.11M	\|\| (1.04M c >= 0x1ee051.04M && c <= 0x1ee1f987k ) \|\| (1.04M c >= 0x1ee211.04M && c <= 0x1ee22987k ) \|\| c == 0x1ee241.04M \|\| c == 0x1ee271.04M
160	1.11M	\|\| (1.04M c >= 0x1ee291.04M && c <= 0x1ee32987k ) \|\| (1.04M c >= 0x1ee341.04M && c <= 0x1ee37987k ) \|\| c == 0x1ee391.04M \|\| c == 0x1ee3b1.04M
161	1.11M	\|\| c == 0x1ee421.04M \|\| c == 0x1ee471.04M \|\| c == 0x1ee491.04M \|\| c == 0x1ee4b1.04M
162	1.11M	\|\| (1.04M c >= 0x1ee4d1.04M && c <= 0x1ee4f987k ) \|\| (1.04M c >= 0x1ee511.04M && c <= 0x1ee52987k ) \|\| c == 0x1ee541.04M \|\| c == 0x1ee571.04M
163	1.11M	\|\| c == 0x1ee591.04M \|\| c == 0x1ee5b1.04M \|\| c == 0x1ee5d1.04M \|\| c == 0x1ee5f1.04M
164	1.11M	\|\| (1.04M c >= 0x1ee611.04M && c <= 0x1ee62987k ) \|\| c == 0x1ee641.04M \|\| (1.04M c >= 0x1ee671.04M && c <= 0x1ee6a987k ) \|\| (1.04M c >= 0x1ee6c1.04M && c <= 0x1ee72987k )
165	1.11M	\|\| (1.04M c >= 0x1ee741.04M && c <= 0x1ee77987k ) \|\| (1.04M c >= 0x1ee791.04M && c <= 0x1ee7c987k ) \|\| c == 0x1ee7e1.04M \|\| (1.04M c >= 0x1ee801.04M && c <= 0x1ee89987k )
166	1.11M	\|\| (1.04M c >= 0x1ee8b1.04M && c <= 0x1ee9b987k ) \|\| (1.04M c >= 0x1eea11.04M && c <= 0x1eea3987k ) \|\| (1.04M c >= 0x1eea51.04M && c <= 0x1eea9987k ) \|\| (1.04M c >= 0x1eeab1.04M && c <= 0x1eebb987k )
167	1.11M	\|\| (1.04M c >= 0x200001.04M && c <= 0x2a6d6983k ) \|\| (1.00M c >= 0x2a7001.00M && c <= 0x2b734940k ) \|\| (1.00M c >= 0x2b7401.00M && c <= 0x2b81d936k ) \|\| (1.00M c >= 0x2b8201.00M && c <= 0x2cea1935k )
168	1.11M	\|\| (996k c >= 0x2ceb0996k && c <= 0x2ebe0930k ) \|\| (989k c >= 0x2f800989k && c <= 0x2fa1d919k );
169	1.11M	}
170
171
172	1.11M	bool isIdContinueChar(char32_t c) {
173	1.11M	return
174	1.11M	(c >= 'a' && c <= 'z'1.11M )
175	1.11M	\|\| (1.11M c >= 'A'1.11M && c <= 'Z'1.11M )
176	1.11M	\|\| (1.11M c >= '0'1.11M && c <= '9'1.11M )
177	1.11M	\|\| c == '$'1.11M
178	1.11M	\|\| c == '_'1.11M
179	1.11M	\|\| c == 0x200c1.11M
180	1.11M	\|\| c == 0x200d1.11M
181	1.11M	\|\| c == 0xaa1.11M \|\| c == 0xb51.11M \|\| c == 0xba1.11M \|\| (1.11M c >= 0xc01.11M && c <= 0xd61.11M )
182	1.11M	\|\| (1.11M c >= 0xd81.11M && c <= 0xf61.11M ) \|\| (1.11M c >= 0xf81.11M && c <= 0x2c11.11M ) \|\| (1.11M c >= 0x2c61.11M && c <= 0x2d11.11M ) \|\| (1.11M c >= 0x2e01.11M && c <= 0x2e41.11M )
183	1.11M	\|\| c == 0x2ec1.11M \|\| c == 0x2ee1.11M \|\| (1.11M c >= 0x3001.11M && c <= 0x3741.11M ) \|\| (1.11M c >= 0x3761.11M && c <= 0x3771.11M )
184	1.11M	\|\| (1.11M c >= 0x37a1.11M && c <= 0x37d1.11M ) \|\| c == 0x37f1.11M \|\| c == 0x3861.11M \|\| (1.11M c >= 0x3881.11M && c <= 0x38a1.11M )
185	1.11M	\|\| c == 0x38c1.11M \|\| (1.11M c >= 0x38e1.11M && c <= 0x3a11.11M ) \|\| (1.11M c >= 0x3a31.11M && c <= 0x3f51.11M ) \|\| (1.11M c >= 0x3f71.11M && c <= 0x4811.11M )
186	1.11M	\|\| (1.11M c >= 0x4831.11M && c <= 0x4871.11M ) \|\| (1.11M c >= 0x48a1.11M && c <= 0x52f1.11M ) \|\| (1.11M c >= 0x5311.11M && c <= 0x5561.11M ) \|\| c == 0x5591.11M
187	1.11M	\|\| (1.11M c >= 0x5611.11M && c <= 0x5871.11M ) \|\| (1.11M c >= 0x5911.11M && c <= 0x5bd1.11M ) \|\| c == 0x5bf1.11M \|\| (1.11M c >= 0x5c11.11M && c <= 0x5c21.11M )
188	1.11M	\|\| (1.11M c >= 0x5c41.11M && c <= 0x5c51.11M ) \|\| c == 0x5c71.11M \|\| (1.11M c >= 0x5d01.11M && c <= 0x5ea1.11M ) \|\| (1.11M c >= 0x5f01.11M && c <= 0x5f21.11M )
189	1.11M	\|\| (1.11M c >= 0x6101.11M && c <= 0x61a1.11M ) \|\| (1.11M c >= 0x6201.11M && c <= 0x6691.11M ) \|\| (1.11M c >= 0x66e1.11M && c <= 0x6d31.11M ) \|\| (1.11M c >= 0x6d51.11M && c <= 0x6dc1.11M )
190	1.11M	\|\| (1.11M c >= 0x6df1.11M && c <= 0x6e81.11M ) \|\| (1.11M c >= 0x6ea1.11M && c <= 0x6fc1.11M ) \|\| c == 0x6ff1.11M \|\| (1.11M c >= 0x7101.11M && c <= 0x74a1.11M )
191	1.11M	\|\| (1.11M c >= 0x74d1.11M && c <= 0x7b11.11M ) \|\| (1.11M c >= 0x7c01.11M && c <= 0x7f51.11M ) \|\| c == 0x7fa1.11M \|\| (1.11M c >= 0x8001.11M && c <= 0x82d1.11M )
192	1.11M	\|\| (1.11M c >= 0x8401.11M && c <= 0x85b1.11M ) \|\| (1.11M c >= 0x8601.11M && c <= 0x86a1.11M ) \|\| (1.11M c >= 0x8a01.11M && c <= 0x8b41.11M ) \|\| (1.11M c >= 0x8b61.11M && c <= 0x8bd1.11M )
193	1.11M	\|\| (1.11M c >= 0x8d41.11M && c <= 0x8e11.11M ) \|\| (1.11M c >= 0x8e31.11M && c <= 0x9631.11M ) \|\| (1.11M c >= 0x9661.11M && c <= 0x96f1.11M ) \|\| (1.11M c >= 0x9711.11M && c <= 0x9831.11M )
194	1.11M	\|\| (1.11M c >= 0x9851.11M && c <= 0x98c1.11M ) \|\| (1.11M c >= 0x98f1.11M && c <= 0x9901.11M ) \|\| (1.11M c >= 0x9931.11M && c <= 0x9a81.11M ) \|\| (1.11M c >= 0x9aa1.11M && c <= 0x9b01.11M )
195	1.11M	\|\| c == 0x9b21.11M \|\| (1.11M c >= 0x9b61.11M && c <= 0x9b91.11M ) \|\| (1.11M c >= 0x9bc1.11M && c <= 0x9c41.11M ) \|\| (1.11M c >= 0x9c71.11M && c <= 0x9c81.11M )
196	1.11M	\|\| (1.11M c >= 0x9cb1.11M && c <= 0x9ce1.11M ) \|\| c == 0x9d71.11M \|\| (1.11M c >= 0x9dc1.11M && c <= 0x9dd1.11M ) \|\| (1.11M c >= 0x9df1.11M && c <= 0x9e31.11M )
197	1.11M	\|\| (1.11M c >= 0x9e61.11M && c <= 0x9f11.11M ) \|\| c == 0x9fc1.11M \|\| (1.11M c >= 0xa011.11M && c <= 0xa031.11M ) \|\| (1.11M c >= 0xa051.11M && c <= 0xa0a1.11M )
198	1.11M	\|\| (1.11M c >= 0xa0f1.11M && c <= 0xa101.11M ) \|\| (1.11M c >= 0xa131.11M && c <= 0xa281.11M ) \|\| (1.11M c >= 0xa2a1.11M && c <= 0xa301.11M ) \|\| (1.11M c >= 0xa321.11M && c <= 0xa331.11M )
199	1.11M	\|\| (1.11M c >= 0xa351.11M && c <= 0xa361.11M ) \|\| (1.11M c >= 0xa381.11M && c <= 0xa391.11M ) \|\| c == 0xa3c1.11M \|\| (1.11M c >= 0xa3e1.11M && c <= 0xa421.11M )
200	1.11M	\|\| (1.11M c >= 0xa471.11M && c <= 0xa481.11M ) \|\| (1.11M c >= 0xa4b1.11M && c <= 0xa4d1.11M ) \|\| c == 0xa511.11M \|\| (1.11M c >= 0xa591.11M && c <= 0xa5c1.11M )
201	1.11M	\|\| c == 0xa5e1.11M \|\| (1.11M c >= 0xa661.11M && c <= 0xa751.11M ) \|\| (1.11M c >= 0xa811.11M && c <= 0xa831.11M ) \|\| (1.11M c >= 0xa851.11M && c <= 0xa8d1.11M )
202	1.11M	\|\| (1.11M c >= 0xa8f1.11M && c <= 0xa911.11M ) \|\| (1.11M c >= 0xa931.11M && c <= 0xaa81.11M ) \|\| (1.11M c >= 0xaaa1.11M && c <= 0xab01.11M ) \|\| (1.11M c >= 0xab21.11M && c <= 0xab31.11M )
203	1.11M	\|\| (1.11M c >= 0xab51.11M && c <= 0xab91.11M ) \|\| (1.11M c >= 0xabc1.11M && c <= 0xac51.11M ) \|\| (1.11M c >= 0xac71.11M && c <= 0xac91.11M ) \|\| (1.11M c >= 0xacb1.11M && c <= 0xacd1.11M )
204	1.11M	\|\| c == 0xad01.11M \|\| (1.11M c >= 0xae01.11M && c <= 0xae31.11M ) \|\| (1.11M c >= 0xae61.11M && c <= 0xaef1.11M ) \|\| (1.11M c >= 0xaf91.11M && c <= 0xaff1.11M )
205	1.11M	\|\| (1.11M c >= 0xb011.11M && c <= 0xb031.11M ) \|\| (1.11M c >= 0xb051.11M && c <= 0xb0c1.11M ) \|\| (1.11M c >= 0xb0f1.11M && c <= 0xb101.11M ) \|\| (1.11M c >= 0xb131.11M && c <= 0xb281.11M )
206	1.11M	\|\| (1.11M c >= 0xb2a1.11M && c <= 0xb301.11M ) \|\| (1.11M c >= 0xb321.11M && c <= 0xb331.11M ) \|\| (1.11M c >= 0xb351.11M && c <= 0xb391.11M ) \|\| (1.11M c >= 0xb3c1.11M && c <= 0xb441.11M )
207	1.11M	\|\| (1.11M c >= 0xb471.11M && c <= 0xb481.11M ) \|\| (1.11M c >= 0xb4b1.11M && c <= 0xb4d1.11M ) \|\| (1.11M c >= 0xb561.11M && c <= 0xb571.11M ) \|\| (1.11M c >= 0xb5c1.11M && c <= 0xb5d1.11M )
208	1.11M	\|\| (1.11M c >= 0xb5f1.11M && c <= 0xb631.11M ) \|\| (1.11M c >= 0xb661.11M && c <= 0xb6f1.11M ) \|\| c == 0xb711.11M \|\| (1.11M c >= 0xb821.11M && c <= 0xb831.11M )
209	1.11M	\|\| (1.11M c >= 0xb851.11M && c <= 0xb8a1.11M ) \|\| (1.11M c >= 0xb8e1.11M && c <= 0xb901.11M ) \|\| (1.11M c >= 0xb921.11M && c <= 0xb951.11M ) \|\| (1.11M c >= 0xb991.11M && c <= 0xb9a1.11M )
210	1.11M	\|\| c == 0xb9c1.11M \|\| (1.11M c >= 0xb9e1.11M && c <= 0xb9f1.11M ) \|\| (1.11M c >= 0xba31.11M && c <= 0xba41.11M ) \|\| (1.11M c >= 0xba81.11M && c <= 0xbaa1.11M )
211	1.11M	\|\| (1.11M c >= 0xbae1.11M && c <= 0xbb91.11M ) \|\| (1.11M c >= 0xbbe1.11M && c <= 0xbc21.11M ) \|\| (1.11M c >= 0xbc61.11M && c <= 0xbc81.11M ) \|\| (1.11M c >= 0xbca1.11M && c <= 0xbcd1.11M )
212	1.11M	\|\| c == 0xbd01.11M \|\| c == 0xbd71.11M \|\| (1.11M c >= 0xbe61.11M && c <= 0xbef1.11M ) \|\| (1.11M c >= 0xc001.11M && c <= 0xc031.11M )
213	1.11M	\|\| (1.11M c >= 0xc051.11M && c <= 0xc0c1.11M ) \|\| (1.11M c >= 0xc0e1.11M && c <= 0xc101.11M ) \|\| (1.11M c >= 0xc121.11M && c <= 0xc281.11M ) \|\| (1.11M c >= 0xc2a1.11M && c <= 0xc391.11M )
214	1.11M	\|\| (1.11M c >= 0xc3d1.11M && c <= 0xc441.11M ) \|\| (1.11M c >= 0xc461.11M && c <= 0xc481.11M ) \|\| (1.11M c >= 0xc4a1.11M && c <= 0xc4d1.11M ) \|\| (1.11M c >= 0xc551.11M && c <= 0xc561.11M )
215	1.11M	\|\| (1.11M c >= 0xc581.11M && c <= 0xc5a1.11M ) \|\| (1.11M c >= 0xc601.11M && c <= 0xc631.11M ) \|\| (1.11M c >= 0xc661.11M && c <= 0xc6f1.11M ) \|\| (1.11M c >= 0xc801.11M && c <= 0xc831.11M )
216	1.11M	\|\| (1.11M c >= 0xc851.11M && c <= 0xc8c1.11M ) \|\| (1.11M c >= 0xc8e1.11M && c <= 0xc901.11M ) \|\| (1.11M c >= 0xc921.11M && c <= 0xca81.11M ) \|\| (1.11M c >= 0xcaa1.11M && c <= 0xcb31.11M )
217	1.11M	\|\| (1.11M c >= 0xcb51.11M && c <= 0xcb91.11M ) \|\| (1.11M c >= 0xcbc1.11M && c <= 0xcc41.11M ) \|\| (1.11M c >= 0xcc61.11M && c <= 0xcc81.11M ) \|\| (1.11M c >= 0xcca1.11M && c <= 0xccd1.11M )
218	1.11M	\|\| (1.11M c >= 0xcd51.11M && c <= 0xcd61.11M ) \|\| c == 0xcde1.11M \|\| (1.11M c >= 0xce01.11M && c <= 0xce31.11M ) \|\| (1.11M c >= 0xce61.11M && c <= 0xcef1.11M )
219	1.11M	\|\| (1.11M c >= 0xcf11.11M && c <= 0xcf21.11M ) \|\| (1.11M c >= 0xd001.11M && c <= 0xd031.11M ) \|\| (1.11M c >= 0xd051.11M && c <= 0xd0c1.11M ) \|\| (1.11M c >= 0xd0e1.11M && c <= 0xd101.11M )
220	1.11M	\|\| (1.11M c >= 0xd121.11M && c <= 0xd441.11M ) \|\| (1.11M c >= 0xd461.11M && c <= 0xd481.11M ) \|\| (1.11M c >= 0xd4a1.11M && c <= 0xd4e1.11M ) \|\| (1.11M c >= 0xd541.11M && c <= 0xd571.11M )
221	1.11M	\|\| (1.11M c >= 0xd5f1.11M && c <= 0xd631.11M ) \|\| (1.11M c >= 0xd661.11M && c <= 0xd6f1.11M ) \|\| (1.11M c >= 0xd7a1.11M && c <= 0xd7f1.11M ) \|\| (1.11M c >= 0xd821.11M && c <= 0xd831.11M )
222	1.11M	\|\| (1.11M c >= 0xd851.11M && c <= 0xd961.11M ) \|\| (1.11M c >= 0xd9a1.11M && c <= 0xdb11.11M ) \|\| (1.11M c >= 0xdb31.11M && c <= 0xdbb1.11M ) \|\| c == 0xdbd1.11M
223	1.11M	\|\| (1.11M c >= 0xdc01.11M && c <= 0xdc61.11M ) \|\| c == 0xdca1.11M \|\| (1.11M c >= 0xdcf1.11M && c <= 0xdd41.11M ) \|\| c == 0xdd61.11M
224	1.11M	\|\| (1.11M c >= 0xdd81.11M && c <= 0xddf1.11M ) \|\| (1.11M c >= 0xde61.11M && c <= 0xdef1.11M ) \|\| (1.11M c >= 0xdf21.11M && c <= 0xdf31.11M ) \|\| (1.11M c >= 0xe011.11M && c <= 0xe3a1.11M )
225	1.11M	\|\| (1.11M c >= 0xe401.11M && c <= 0xe4e1.11M ) \|\| (1.11M c >= 0xe501.11M && c <= 0xe591.11M ) \|\| (1.11M c >= 0xe811.11M && c <= 0xe821.11M ) \|\| c == 0xe841.11M
226	1.11M	\|\| (1.11M c >= 0xe871.11M && c <= 0xe881.11M ) \|\| c == 0xe8a1.11M \|\| c == 0xe8d1.11M \|\| (1.11M c >= 0xe941.11M && c <= 0xe971.11M )
227	1.11M	\|\| (1.11M c >= 0xe991.11M && c <= 0xe9f1.11M ) \|\| (1.11M c >= 0xea11.11M && c <= 0xea31.11M ) \|\| c == 0xea51.11M \|\| c == 0xea71.11M
228	1.11M	\|\| (1.11M c >= 0xeaa1.11M && c <= 0xeab1.11M ) \|\| (1.11M c >= 0xead1.11M && c <= 0xeb91.11M ) \|\| (1.11M c >= 0xebb1.11M && c <= 0xebd1.11M ) \|\| (1.11M c >= 0xec01.11M && c <= 0xec41.11M )
229	1.11M	\|\| c == 0xec61.11M \|\| (1.11M c >= 0xec81.11M && c <= 0xecd1.11M ) \|\| (1.11M c >= 0xed01.11M && c <= 0xed91.11M ) \|\| (1.11M c >= 0xedc1.11M && c <= 0xedf1.11M )
230	1.11M	\|\| c == 0xf001.11M \|\| (1.11M c >= 0xf181.11M && c <= 0xf191.11M ) \|\| (1.11M c >= 0xf201.11M && c <= 0xf291.11M ) \|\| c == 0xf351.11M
231	1.11M	\|\| c == 0xf371.11M \|\| c == 0xf391.11M \|\| (1.11M c >= 0xf3e1.11M && c <= 0xf471.11M ) \|\| (1.11M c >= 0xf491.11M && c <= 0xf6c1.11M )
232	1.11M	\|\| (1.11M c >= 0xf711.11M && c <= 0xf841.11M ) \|\| (1.11M c >= 0xf861.11M && c <= 0xf971.11M ) \|\| (1.11M c >= 0xf991.11M && c <= 0xfbc1.11M ) \|\| c == 0xfc61.11M
233	1.11M	\|\| (1.11M c >= 0x10001.11M && c <= 0x10491.11M ) \|\| (1.11M c >= 0x10501.11M && c <= 0x109d1.10M ) \|\| (1.11M c >= 0x10a01.11M && c <= 0x10c51.10M ) \|\| c == 0x10c71.11M
234	1.11M	\|\| c == 0x10cd1.11M \|\| (1.11M c >= 0x10d01.11M && c <= 0x10fa1.10M ) \|\| (1.11M c >= 0x10fc1.11M && c <= 0x12481.10M ) \|\| (1.11M c >= 0x124a1.11M && c <= 0x124d1.10M )
235	1.11M	\|\| (1.11M c >= 0x12501.11M && c <= 0x12561.10M ) \|\| c == 0x12581.11M \|\| (1.11M c >= 0x125a1.11M && c <= 0x125d1.10M ) \|\| (1.11M c >= 0x12601.11M && c <= 0x12881.10M )
236	1.11M	\|\| (1.11M c >= 0x128a1.11M && c <= 0x128d1.10M ) \|\| (1.11M c >= 0x12901.11M && c <= 0x12b01.10M ) \|\| (1.11M c >= 0x12b21.11M && c <= 0x12b51.10M ) \|\| (1.11M c >= 0x12b81.11M && c <= 0x12be1.10M )
237	1.11M	\|\| c == 0x12c01.11M \|\| (1.11M c >= 0x12c21.11M && c <= 0x12c51.10M ) \|\| (1.11M c >= 0x12c81.11M && c <= 0x12d61.10M ) \|\| (1.11M c >= 0x12d81.11M && c <= 0x13101.10M )
238	1.11M	\|\| (1.11M c >= 0x13121.11M && c <= 0x13151.10M ) \|\| (1.11M c >= 0x13181.11M && c <= 0x135a1.10M ) \|\| (1.11M c >= 0x135d1.11M && c <= 0x135f1.10M ) \|\| (1.11M c >= 0x13801.11M && c <= 0x138f1.10M )
239	1.11M	\|\| (1.11M c >= 0x13a01.11M && c <= 0x13f51.10M ) \|\| (1.11M c >= 0x13f81.11M && c <= 0x13fd1.10M ) \|\| (1.11M c >= 0x14011.11M && c <= 0x166c1.10M ) \|\| (1.10M c >= 0x166f1.10M && c <= 0x167f1.10M )
240	1.11M	\|\| (1.10M c >= 0x16811.10M && c <= 0x169a1.10M ) \|\| (1.10M c >= 0x16a01.10M && c <= 0x16ea1.10M ) \|\| (1.10M c >= 0x16ee1.10M && c <= 0x16f81.10M ) \|\| (1.10M c >= 0x17001.10M && c <= 0x170c1.10M )
241	1.11M	\|\| (1.10M c >= 0x170e1.10M && c <= 0x17141.10M ) \|\| (1.10M c >= 0x17201.10M && c <= 0x17341.10M ) \|\| (1.10M c >= 0x17401.10M && c <= 0x17531.10M ) \|\| (1.10M c >= 0x17601.10M && c <= 0x176c1.10M )
242	1.11M	\|\| (1.10M c >= 0x176e1.10M && c <= 0x17701.10M ) \|\| (1.10M c >= 0x17721.10M && c <= 0x17731.10M ) \|\| (1.10M c >= 0x17801.10M && c <= 0x17d31.10M ) \|\| c == 0x17d71.10M
243	1.11M	\|\| (1.10M c >= 0x17dc1.10M && c <= 0x17dd1.10M ) \|\| (1.10M c >= 0x17e01.10M && c <= 0x17e91.10M ) \|\| (1.10M c >= 0x180b1.10M && c <= 0x180d1.10M ) \|\| (1.10M c >= 0x18101.10M && c <= 0x18191.10M )
244	1.11M	\|\| (1.10M c >= 0x18201.10M && c <= 0x18771.10M ) \|\| (1.10M c >= 0x18801.10M && c <= 0x18aa1.10M ) \|\| (1.10M c >= 0x18b01.10M && c <= 0x18f51.10M ) \|\| (1.10M c >= 0x19001.10M && c <= 0x191e1.10M )
245	1.11M	\|\| (1.10M c >= 0x19201.10M && c <= 0x192b1.10M ) \|\| (1.10M c >= 0x19301.10M && c <= 0x193b1.10M ) \|\| (1.10M c >= 0x19461.10M && c <= 0x196d1.10M ) \|\| (1.10M c >= 0x19701.10M && c <= 0x19741.10M )
246	1.11M	\|\| (1.10M c >= 0x19801.10M && c <= 0x19ab1.10M ) \|\| (1.10M c >= 0x19b01.10M && c <= 0x19c91.10M ) \|\| (1.10M c >= 0x19d01.10M && c <= 0x19d91.10M ) \|\| (1.10M c >= 0x1a001.10M && c <= 0x1a1b1.10M )
247	1.11M	\|\| (1.10M c >= 0x1a201.10M && c <= 0x1a5e1.10M ) \|\| (1.10M c >= 0x1a601.10M && c <= 0x1a7c1.10M ) \|\| (1.10M c >= 0x1a7f1.10M && c <= 0x1a891.10M ) \|\| (1.10M c >= 0x1a901.10M && c <= 0x1a991.10M )
248	1.11M	\|\| c == 0x1aa71.10M \|\| (1.10M c >= 0x1ab01.10M && c <= 0x1abd1.10M ) \|\| (1.10M c >= 0x1b001.10M && c <= 0x1b4b1.10M ) \|\| (1.10M c >= 0x1b501.10M && c <= 0x1b591.10M )
249	1.11M	\|\| (1.10M c >= 0x1b6b1.10M && c <= 0x1b731.10M ) \|\| (1.10M c >= 0x1b801.10M && c <= 0x1bf31.10M ) \|\| (1.10M c >= 0x1c001.10M && c <= 0x1c371.10M ) \|\| (1.10M c >= 0x1c401.10M && c <= 0x1c491.10M )
250	1.11M	\|\| (1.10M c >= 0x1c4d1.10M && c <= 0x1c7d1.10M ) \|\| (1.10M c >= 0x1c801.10M && c <= 0x1c881.10M ) \|\| (1.10M c >= 0x1cd01.10M && c <= 0x1cd21.10M ) \|\| (1.10M c >= 0x1cd41.10M && c <= 0x1cf91.10M )
251	1.11M	\|\| (1.10M c >= 0x1d001.10M && c <= 0x1df91.10M ) \|\| (1.10M c >= 0x1dfb1.10M && c <= 0x1f151.10M ) \|\| (1.10M c >= 0x1f181.10M && c <= 0x1f1d1.10M ) \|\| (1.10M c >= 0x1f201.10M && c <= 0x1f451.10M )
252	1.11M	\|\| (1.10M c >= 0x1f481.10M && c <= 0x1f4d1.10M ) \|\| (1.10M c >= 0x1f501.10M && c <= 0x1f571.10M ) \|\| c == 0x1f591.10M \|\| c == 0x1f5b1.10M
253	1.11M	\|\| c == 0x1f5d1.10M \|\| (1.10M c >= 0x1f5f1.10M && c <= 0x1f7d1.10M ) \|\| (1.10M c >= 0x1f801.10M && c <= 0x1fb41.10M ) \|\| (1.10M c >= 0x1fb61.10M && c <= 0x1fbc1.10M )
254	1.11M	\|\| c == 0x1fbe1.10M \|\| (1.10M c >= 0x1fc21.10M && c <= 0x1fc41.10M ) \|\| (1.10M c >= 0x1fc61.10M && c <= 0x1fcc1.10M ) \|\| (1.10M c >= 0x1fd01.10M && c <= 0x1fd31.10M )
255	1.11M	\|\| (1.10M c >= 0x1fd61.10M && c <= 0x1fdb1.10M ) \|\| (1.10M c >= 0x1fe01.10M && c <= 0x1fec1.10M ) \|\| (1.10M c >= 0x1ff21.10M && c <= 0x1ff41.10M ) \|\| (1.10M c >= 0x1ff61.10M && c <= 0x1ffc1.10M )
256	1.11M	\|\| (1.10M c >= 0x203f1.10M && c <= 0x20401.10M ) \|\| c == 0x20541.10M \|\| c == 0x20711.10M \|\| c == 0x207f1.10M
257	1.11M	\|\| (1.10M c >= 0x20901.10M && c <= 0x209c1.10M ) \|\| (1.10M c >= 0x20d01.10M && c <= 0x20dc1.10M ) \|\| c == 0x20e11.10M \|\| (1.10M c >= 0x20e51.10M && c <= 0x20f01.10M )
258	1.11M	\|\| c == 0x21021.10M \|\| c == 0x21071.10M \|\| (1.10M c >= 0x210a1.10M && c <= 0x21131.10M ) \|\| c == 0x21151.10M
259	1.11M	\|\| (1.10M c >= 0x21191.10M && c <= 0x211d1.10M ) \|\| c == 0x21241.10M \|\| c == 0x21261.10M \|\| c == 0x21281.10M
260	1.11M	\|\| (1.10M c >= 0x212a1.10M && c <= 0x212d1.10M ) \|\| (1.10M c >= 0x212f1.10M && c <= 0x21391.10M ) \|\| (1.10M c >= 0x213c1.10M && c <= 0x213f1.10M ) \|\| (1.10M c >= 0x21451.10M && c <= 0x21491.10M )
261	1.11M	\|\| c == 0x214e1.10M \|\| (1.10M c >= 0x21601.10M && c <= 0x21881.10M ) \|\| (1.10M c >= 0x2c001.10M && c <= 0x2c2e1.10M ) \|\| (1.10M c >= 0x2c301.10M && c <= 0x2c5e1.10M )
262	1.11M	\|\| (1.10M c >= 0x2c601.10M && c <= 0x2ce41.10M ) \|\| (1.10M c >= 0x2ceb1.10M && c <= 0x2cf31.10M ) \|\| (1.10M c >= 0x2d001.10M && c <= 0x2d251.10M ) \|\| c == 0x2d271.10M
263	1.11M	\|\| c == 0x2d2d1.10M \|\| (1.10M c >= 0x2d301.10M && c <= 0x2d671.10M ) \|\| c == 0x2d6f1.10M \|\| (1.10M c >= 0x2d7f1.10M && c <= 0x2d961.10M )
264	1.11M	\|\| (1.10M c >= 0x2da01.10M && c <= 0x2da61.10M ) \|\| (1.10M c >= 0x2da81.10M && c <= 0x2dae1.10M ) \|\| (1.10M c >= 0x2db01.10M && c <= 0x2db61.10M ) \|\| (1.10M c >= 0x2db81.10M && c <= 0x2dbe1.10M )
265	1.11M	\|\| (1.10M c >= 0x2dc01.10M && c <= 0x2dc61.10M ) \|\| (1.10M c >= 0x2dc81.10M && c <= 0x2dce1.10M ) \|\| (1.10M c >= 0x2dd01.10M && c <= 0x2dd61.10M ) \|\| (1.10M c >= 0x2dd81.10M && c <= 0x2dde1.10M )
266	1.11M	\|\| (1.10M c >= 0x2de01.10M && c <= 0x2dff1.10M ) \|\| c == 0x2e2f1.10M \|\| (1.10M c >= 0x30051.10M && c <= 0x30071.10M ) \|\| (1.10M c >= 0x30211.10M && c <= 0x302f1.10M )
267	1.11M	\|\| (1.10M c >= 0x30311.10M && c <= 0x30351.10M ) \|\| (1.10M c >= 0x30381.10M && c <= 0x303c1.10M ) \|\| (1.10M c >= 0x30411.10M && c <= 0x30961.10M ) \|\| (1.10M c >= 0x30991.10M && c <= 0x309a1.10M )
268	1.11M	\|\| (1.10M c >= 0x309d1.10M && c <= 0x309f1.10M ) \|\| (1.10M c >= 0x30a11.10M && c <= 0x30fa1.10M ) \|\| (1.10M c >= 0x30fc1.10M && c <= 0x30ff1.10M ) \|\| (1.10M c >= 0x31051.10M && c <= 0x312e1.10M )
269	1.11M	\|\| (1.10M c >= 0x31311.10M && c <= 0x318e1.10M ) \|\| (1.10M c >= 0x31a01.10M && c <= 0x31ba1.10M ) \|\| (1.10M c >= 0x31f01.10M && c <= 0x31ff1.10M ) \|\| (1.10M c >= 0x34001.10M && c <= 0x4db51.10M )
270	1.11M	\|\| (1.10M c >= 0x4e001.10M && c <= 0x9fea1.09M ) \|\| (1.07M c >= 0xa0001.07M && c <= 0xa48c1.07M ) \|\| (1.07M c >= 0xa4d01.07M && c <= 0xa4fd1.07M ) \|\| (1.07M c >= 0xa5001.07M && c <= 0xa60c1.07M )
271	1.11M	\|\| (1.07M c >= 0xa6101.07M && c <= 0xa62b1.07M ) \|\| (1.07M c >= 0xa6401.07M && c <= 0xa66f1.07M ) \|\| (1.07M c >= 0xa6741.07M && c <= 0xa67d1.07M ) \|\| (1.07M c >= 0xa67f1.07M && c <= 0xa6f11.07M )
272	1.11M	\|\| (1.07M c >= 0xa7171.07M && c <= 0xa71f1.07M ) \|\| (1.07M c >= 0xa7221.07M && c <= 0xa7881.07M ) \|\| (1.07M c >= 0xa78b1.07M && c <= 0xa7ae1.07M ) \|\| (1.07M c >= 0xa7b01.07M && c <= 0xa7b71.07M )
273	1.11M	\|\| (1.07M c >= 0xa7f71.07M && c <= 0xa8271.07M ) \|\| (1.07M c >= 0xa8401.07M && c <= 0xa8731.07M ) \|\| (1.07M c >= 0xa8801.07M && c <= 0xa8c51.07M ) \|\| (1.07M c >= 0xa8d01.07M && c <= 0xa8d91.07M )
274	1.11M	\|\| (1.07M c >= 0xa8e01.07M && c <= 0xa8f71.07M ) \|\| c == 0xa8fb1.07M \|\| c == 0xa8fd1.07M \|\| (1.07M c >= 0xa9001.07M && c <= 0xa92d1.07M )
275	1.11M	\|\| (1.07M c >= 0xa9301.07M && c <= 0xa9531.07M ) \|\| (1.07M c >= 0xa9601.07M && c <= 0xa97c1.07M ) \|\| (1.07M c >= 0xa9801.07M && c <= 0xa9c01.07M ) \|\| (1.07M c >= 0xa9cf1.07M && c <= 0xa9d91.07M )
276	1.11M	\|\| (1.07M c >= 0xa9e01.07M && c <= 0xa9fe1.07M ) \|\| (1.07M c >= 0xaa001.07M && c <= 0xaa361.07M ) \|\| (1.07M c >= 0xaa401.07M && c <= 0xaa4d1.07M ) \|\| (1.07M c >= 0xaa501.07M && c <= 0xaa591.07M )
277	1.11M	\|\| (1.07M c >= 0xaa601.07M && c <= 0xaa761.07M ) \|\| (1.07M c >= 0xaa7a1.07M && c <= 0xaac21.07M ) \|\| (1.07M c >= 0xaadb1.07M && c <= 0xaadd1.07M ) \|\| (1.07M c >= 0xaae01.07M && c <= 0xaaef1.07M )
278	1.11M	\|\| (1.07M c >= 0xaaf21.07M && c <= 0xaaf61.07M ) \|\| (1.07M c >= 0xab011.07M && c <= 0xab061.07M ) \|\| (1.07M c >= 0xab091.07M && c <= 0xab0e1.07M ) \|\| (1.07M c >= 0xab111.07M && c <= 0xab161.07M )
279	1.11M	\|\| (1.07M c >= 0xab201.07M && c <= 0xab261.07M ) \|\| (1.07M c >= 0xab281.07M && c <= 0xab2e1.07M ) \|\| (1.07M c >= 0xab301.07M && c <= 0xab5a1.07M ) \|\| (1.07M c >= 0xab5c1.07M && c <= 0xab651.07M )
280	1.11M	\|\| (1.07M c >= 0xab701.07M && c <= 0xabea1.07M ) \|\| (1.07M c >= 0xabec1.07M && c <= 0xabed1.07M ) \|\| (1.07M c >= 0xabf01.07M && c <= 0xabf91.07M ) \|\| (1.07M c >= 0xac001.07M && c <= 0xd7a31.07M )
281	1.11M	\|\| (1.06M c >= 0xd7b01.06M && c <= 0xd7c61.05M ) \|\| (1.06M c >= 0xd7cb1.06M && c <= 0xd7fb1.05M ) \|\| (1.06M c >= 0xf9001.06M && c <= 0xfa6d1.05M ) \|\| (1.06M c >= 0xfa701.06M && c <= 0xfad91.05M )
282	1.11M	\|\| (1.06M c >= 0xfb001.06M && c <= 0xfb061.04M ) \|\| (1.06M c >= 0xfb131.06M && c <= 0xfb171.04M ) \|\| (1.06M c >= 0xfb1d1.06M && c <= 0xfb281.04M ) \|\| (1.06M c >= 0xfb2a1.06M && c <= 0xfb361.04M )
283	1.11M	\|\| (1.06M c >= 0xfb381.06M && c <= 0xfb3c1.04M ) \|\| c == 0xfb3e1.06M \|\| (1.06M c >= 0xfb401.06M && c <= 0xfb411.04M ) \|\| (1.06M c >= 0xfb431.06M && c <= 0xfb441.04M )
284	1.11M	\|\| (1.06M c >= 0xfb461.06M && c <= 0xfbb11.04M ) \|\| (1.06M c >= 0xfbd31.06M && c <= 0xfd3d1.04M ) \|\| (1.06M c >= 0xfd501.06M && c <= 0xfd8f1.04M ) \|\| (1.06M c >= 0xfd921.06M && c <= 0xfdc71.04M )
285	1.11M	\|\| (1.06M c >= 0xfdf01.06M && c <= 0xfdfb1.04M ) \|\| (1.06M c >= 0xfe001.06M && c <= 0xfe0f1.04M ) \|\| (1.06M c >= 0xfe201.06M && c <= 0xfe2f1.04M ) \|\| (1.06M c >= 0xfe331.06M && c <= 0xfe341.04M )
286	1.11M	\|\| (1.06M c >= 0xfe4d1.06M && c <= 0xfe4f1.04M ) \|\| (1.06M c >= 0xfe701.06M && c <= 0xfe741.04M ) \|\| (1.06M c >= 0xfe761.06M && c <= 0xfefc1.04M ) \|\| (1.06M c >= 0xff101.06M && c <= 0xff191.04M )
287	1.11M	\|\| (1.06M c >= 0xff211.06M && c <= 0xff3a1.04M ) \|\| c == 0xff3f1.06M \|\| (1.06M c >= 0xff411.06M && c <= 0xff5a1.04M ) \|\| (1.06M c >= 0xff661.06M && c <= 0xffbe1.04M )
288	1.11M	\|\| (1.06M c >= 0xffc21.06M && c <= 0xffc71.04M ) \|\| (1.06M c >= 0xffca1.06M && c <= 0xffcf1.04M ) \|\| (1.06M c >= 0xffd21.06M && c <= 0xffd71.04M ) \|\| (1.06M c >= 0xffda1.06M && c <= 0xffdc1.04M )
289	1.11M	\|\| (1.06M c >= 0x100001.06M && c <= 0x1000b1.04M ) \|\| (1.06M c >= 0x1000d1.06M && c <= 0x100261.04M ) \|\| (1.06M c >= 0x100281.06M && c <= 0x1003a1.04M ) \|\| (1.06M c >= 0x1003c1.06M && c <= 0x1003d1.04M )
290	1.11M	\|\| (1.06M c >= 0x1003f1.06M && c <= 0x1004d1.04M ) \|\| (1.06M c >= 0x100501.06M && c <= 0x1005d1.04M ) \|\| (1.06M c >= 0x100801.06M && c <= 0x100fa1.04M ) \|\| (1.06M c >= 0x101401.06M && c <= 0x101741.04M )
291	1.11M	\|\| c == 0x101fd1.06M \|\| (1.06M c >= 0x102801.06M && c <= 0x1029c1.04M ) \|\| (1.06M c >= 0x102a01.06M && c <= 0x102d01.04M ) \|\| c == 0x102e01.06M
292	1.11M	\|\| (1.06M c >= 0x103001.06M && c <= 0x1031f1.04M ) \|\| (1.06M c >= 0x1032d1.06M && c <= 0x1034a1.04M ) \|\| (1.06M c >= 0x103501.06M && c <= 0x1037a1.04M ) \|\| (1.06M c >= 0x103801.06M && c <= 0x1039d1.04M )
293	1.11M	\|\| (1.06M c >= 0x103a01.06M && c <= 0x103c31.04M ) \|\| (1.06M c >= 0x103c81.06M && c <= 0x103cf1.04M ) \|\| (1.06M c >= 0x103d11.06M && c <= 0x103d51.04M ) \|\| (1.06M c >= 0x104001.06M && c <= 0x1049d1.04M )
294	1.11M	\|\| (1.06M c >= 0x104a01.06M && c <= 0x104a91.04M ) \|\| (1.06M c >= 0x104b01.06M && c <= 0x104d31.04M ) \|\| (1.06M c >= 0x104d81.06M && c <= 0x104fb1.04M ) \|\| (1.06M c >= 0x105001.06M && c <= 0x105271.04M )
295	1.11M	\|\| (1.06M c >= 0x105301.06M && c <= 0x105631.04M ) \|\| (1.06M c >= 0x106001.06M && c <= 0x107361.04M ) \|\| (1.06M c >= 0x107401.06M && c <= 0x107551.04M ) \|\| (1.06M c >= 0x107601.06M && c <= 0x107671.04M )
296	1.11M	\|\| (1.06M c >= 0x108001.06M && c <= 0x108051.04M ) \|\| c == 0x108081.06M \|\| (1.06M c >= 0x1080a1.06M && c <= 0x108351.04M ) \|\| (1.06M c >= 0x108371.06M && c <= 0x108381.04M )
297	1.11M	\|\| c == 0x1083c1.06M \|\| (1.06M c >= 0x1083f1.06M && c <= 0x108551.04M ) \|\| (1.06M c >= 0x108601.06M && c <= 0x108761.04M ) \|\| (1.06M c >= 0x108801.06M && c <= 0x1089e1.04M )
298	1.11M	\|\| (1.06M c >= 0x108e01.06M && c <= 0x108f21.04M ) \|\| (1.06M c >= 0x108f41.06M && c <= 0x108f51.04M ) \|\| (1.06M c >= 0x109001.06M && c <= 0x109151.04M ) \|\| (1.06M c >= 0x109201.06M && c <= 0x109391.04M )
299	1.11M	\|\| (1.06M c >= 0x109801.06M && c <= 0x109b71.04M ) \|\| (1.06M c >= 0x109be1.06M && c <= 0x109bf1.04M ) \|\| (1.06M c >= 0x10a001.06M && c <= 0x10a031.04M ) \|\| (1.06M c >= 0x10a051.06M && c <= 0x10a061.04M )
300	1.11M	\|\| (1.06M c >= 0x10a0c1.06M && c <= 0x10a131.04M ) \|\| (1.06M c >= 0x10a151.06M && c <= 0x10a171.04M ) \|\| (1.06M c >= 0x10a191.06M && c <= 0x10a331.04M ) \|\| (1.06M c >= 0x10a381.06M && c <= 0x10a3a1.04M )
301	1.11M	\|\| c == 0x10a3f1.06M \|\| (1.06M c >= 0x10a601.06M && c <= 0x10a7c1.04M ) \|\| (1.06M c >= 0x10a801.06M && c <= 0x10a9c1.04M ) \|\| (1.06M c >= 0x10ac01.06M && c <= 0x10ac71.04M )
302	1.11M	\|\| (1.06M c >= 0x10ac91.06M && c <= 0x10ae61.04M ) \|\| (1.06M c >= 0x10b001.06M && c <= 0x10b351.04M ) \|\| (1.06M c >= 0x10b401.06M && c <= 0x10b551.04M ) \|\| (1.06M c >= 0x10b601.06M && c <= 0x10b721.04M )
303	1.11M	\|\| (1.06M c >= 0x10b801.06M && c <= 0x10b911.04M ) \|\| (1.06M c >= 0x10c001.06M && c <= 0x10c481.04M ) \|\| (1.06M c >= 0x10c801.06M && c <= 0x10cb21.04M ) \|\| (1.06M c >= 0x10cc01.06M && c <= 0x10cf21.04M )
304	1.11M	\|\| (1.06M c >= 0x110001.06M && c <= 0x110461.04M ) \|\| (1.06M c >= 0x110661.06M && c <= 0x1106f1.04M ) \|\| (1.06M c >= 0x1107f1.06M && c <= 0x110ba1.04M ) \|\| (1.06M c >= 0x110d01.06M && c <= 0x110e81.04M )
305	1.11M	\|\| (1.06M c >= 0x110f01.06M && c <= 0x110f91.04M ) \|\| (1.06M c >= 0x111001.06M && c <= 0x111341.04M ) \|\| (1.06M c >= 0x111361.06M && c <= 0x1113f1.04M ) \|\| (1.06M c >= 0x111501.06M && c <= 0x111731.04M )
306	1.11M	\|\| c == 0x111761.06M \|\| (1.06M c >= 0x111801.06M && c <= 0x111c41.04M ) \|\| (1.06M c >= 0x111ca1.06M && c <= 0x111cc1.04M ) \|\| (1.06M c >= 0x111d01.06M && c <= 0x111da1.04M )
307	1.11M	\|\| c == 0x111dc1.06M \|\| (1.06M c >= 0x112001.06M && c <= 0x112111.04M ) \|\| (1.06M c >= 0x112131.06M && c <= 0x112371.04M ) \|\| c == 0x1123e1.06M
308	1.11M	\|\| (1.06M c >= 0x112801.06M && c <= 0x112861.04M ) \|\| c == 0x112881.06M \|\| (1.06M c >= 0x1128a1.06M && c <= 0x1128d1.04M ) \|\| (1.06M c >= 0x1128f1.06M && c <= 0x1129d1.04M )
309	1.11M	\|\| (1.06M c >= 0x1129f1.06M && c <= 0x112a81.04M ) \|\| (1.06M c >= 0x112b01.06M && c <= 0x112ea1.04M ) \|\| (1.06M c >= 0x112f01.06M && c <= 0x112f91.04M ) \|\| (1.06M c >= 0x113001.06M && c <= 0x113031.04M )
310	1.11M	\|\| (1.06M c >= 0x113051.06M && c <= 0x1130c1.04M ) \|\| (1.06M c >= 0x1130f1.06M && c <= 0x113101.04M ) \|\| (1.06M c >= 0x113131.06M && c <= 0x113281.04M ) \|\| (1.06M c >= 0x1132a1.06M && c <= 0x113301.04M )
311	1.11M	\|\| (1.06M c >= 0x113321.06M && c <= 0x113331.04M ) \|\| (1.06M c >= 0x113351.06M && c <= 0x113391.04M ) \|\| (1.06M c >= 0x1133c1.06M && c <= 0x113441.04M ) \|\| (1.06M c >= 0x113471.06M && c <= 0x113481.04M )
312	1.11M	\|\| (1.06M c >= 0x1134b1.06M && c <= 0x1134d1.04M ) \|\| c == 0x113501.06M \|\| c == 0x113571.06M \|\| (1.06M c >= 0x1135d1.06M && c <= 0x113631.04M )
313	1.11M	\|\| (1.06M c >= 0x113661.06M && c <= 0x1136c1.04M ) \|\| (1.06M c >= 0x113701.06M && c <= 0x113741.04M ) \|\| (1.06M c >= 0x114001.06M && c <= 0x1144a1.04M ) \|\| (1.06M c >= 0x114501.06M && c <= 0x114591.04M )
314	1.11M	\|\| (1.06M c >= 0x114801.06M && c <= 0x114c51.04M ) \|\| c == 0x114c71.06M \|\| (1.06M c >= 0x114d01.06M && c <= 0x114d91.04M ) \|\| (1.06M c >= 0x115801.06M && c <= 0x115b51.04M )
315	1.11M	\|\| (1.06M c >= 0x115b81.06M && c <= 0x115c01.04M ) \|\| (1.06M c >= 0x115d81.06M && c <= 0x115dd1.04M ) \|\| (1.06M c >= 0x116001.06M && c <= 0x116401.04M ) \|\| c == 0x116441.06M
316	1.11M	\|\| (1.06M c >= 0x116501.06M && c <= 0x116591.04M ) \|\| (1.06M c >= 0x116801.06M && c <= 0x116b71.04M ) \|\| (1.06M c >= 0x116c01.06M && c <= 0x116c91.04M ) \|\| (1.06M c >= 0x117001.06M && c <= 0x117191.04M )
317	1.11M	\|\| (1.06M c >= 0x1171d1.06M && c <= 0x1172b1.04M ) \|\| (1.06M c >= 0x117301.06M && c <= 0x117391.04M ) \|\| (1.06M c >= 0x118a01.06M && c <= 0x118e91.04M ) \|\| c == 0x118ff1.06M
318	1.11M	\|\| (1.06M c >= 0x11a001.06M && c <= 0x11a3e1.04M ) \|\| c == 0x11a471.06M \|\| (1.06M c >= 0x11a501.06M && c <= 0x11a831.04M ) \|\| (1.06M c >= 0x11a861.06M && c <= 0x11a991.04M )
319	1.11M	\|\| (1.06M c >= 0x11ac01.06M && c <= 0x11af81.04M ) \|\| (1.06M c >= 0x11c001.06M && c <= 0x11c081.04M ) \|\| (1.06M c >= 0x11c0a1.06M && c <= 0x11c361.04M ) \|\| (1.06M c >= 0x11c381.06M && c <= 0x11c401.04M )
320	1.11M	\|\| (1.06M c >= 0x11c501.06M && c <= 0x11c591.04M ) \|\| (1.06M c >= 0x11c721.06M && c <= 0x11c8f1.04M ) \|\| (1.06M c >= 0x11c921.06M && c <= 0x11ca71.04M ) \|\| (1.06M c >= 0x11ca91.06M && c <= 0x11cb61.04M )
321	1.11M	\|\| (1.06M c >= 0x11d001.06M && c <= 0x11d061.04M ) \|\| (1.06M c >= 0x11d081.06M && c <= 0x11d091.04M ) \|\| (1.06M c >= 0x11d0b1.06M && c <= 0x11d361.04M ) \|\| c == 0x11d3a1.06M
322	1.11M	\|\| (1.06M c >= 0x11d3c1.06M && c <= 0x11d3d1.04M ) \|\| (1.06M c >= 0x11d3f1.06M && c <= 0x11d471.04M ) \|\| (1.06M c >= 0x11d501.06M && c <= 0x11d591.04M ) \|\| (1.06M c >= 0x120001.06M && c <= 0x123991.04M )
323	1.11M	\|\| (1.05M c >= 0x124001.05M && c <= 0x1246e1.03M ) \|\| (1.05M c >= 0x124801.05M && c <= 0x125431.03M ) \|\| (1.05M c >= 0x130001.05M && c <= 0x1342e1.03M ) \|\| (1.05M c >= 0x144001.05M && c <= 0x146461.03M )
324	1.11M	\|\| (1.05M c >= 0x168001.05M && c <= 0x16a381.02M ) \|\| (1.05M c >= 0x16a401.05M && c <= 0x16a5e1.02M ) \|\| (1.05M c >= 0x16a601.05M && c <= 0x16a691.02M ) \|\| (1.05M c >= 0x16ad01.05M && c <= 0x16aed1.02M )
325	1.11M	\|\| (1.05M c >= 0x16af01.05M && c <= 0x16af41.02M ) \|\| (1.05M c >= 0x16b001.05M && c <= 0x16b361.02M ) \|\| (1.05M c >= 0x16b401.05M && c <= 0x16b431.02M ) \|\| (1.05M c >= 0x16b501.05M && c <= 0x16b591.02M )
326	1.11M	\|\| (1.05M c >= 0x16b631.05M && c <= 0x16b771.02M ) \|\| (1.05M c >= 0x16b7d1.05M && c <= 0x16b8f1.02M ) \|\| (1.05M c >= 0x16f001.05M && c <= 0x16f441.02M ) \|\| (1.05M c >= 0x16f501.05M && c <= 0x16f7e1.02M )
327	1.11M	\|\| (1.05M c >= 0x16f8f1.05M && c <= 0x16f9f1.02M ) \|\| (1.05M c >= 0x16fe01.05M && c <= 0x16fe11.01M ) \|\| (1.05M c >= 0x170001.05M && c <= 0x187ec1.01M ) \|\| (1.05M c >= 0x188001.05M && c <= 0x18af21.01M )
328	1.11M	\|\| (1.04M c >= 0x1b0001.04M && c <= 0x1b11e1.00M ) \|\| (1.04M c >= 0x1b1701.04M && c <= 0x1b2fb1.00M ) \|\| (1.04M c >= 0x1bc001.04M && c <= 0x1bc6a1.00M ) \|\| (1.04M c >= 0x1bc701.04M && c <= 0x1bc7c1.00M )
329	1.11M	\|\| (1.04M c >= 0x1bc801.04M && c <= 0x1bc881.00M ) \|\| (1.04M c >= 0x1bc901.04M && c <= 0x1bc991.00M ) \|\| (1.04M c >= 0x1bc9d1.04M && c <= 0x1bc9e1.00M ) \|\| (1.04M c >= 0x1d1651.04M && c <= 0x1d169994k )
330	1.11M	\|\| (1.04M c >= 0x1d16d1.04M && c <= 0x1d172994k ) \|\| (1.04M c >= 0x1d17b1.04M && c <= 0x1d182994k ) \|\| (1.04M c >= 0x1d1851.04M && c <= 0x1d18b994k ) \|\| (1.04M c >= 0x1d1aa1.04M && c <= 0x1d1ad994k )
331	1.11M	\|\| (1.04M c >= 0x1d2421.04M && c <= 0x1d244994k ) \|\| (1.04M c >= 0x1d4001.04M && c <= 0x1d454994k ) \|\| (1.04M c >= 0x1d4561.04M && c <= 0x1d49c994k ) \|\| (1.04M c >= 0x1d49e1.04M && c <= 0x1d49f994k )
332	1.11M	\|\| c == 0x1d4a21.04M \|\| (1.04M c >= 0x1d4a51.04M && c <= 0x1d4a6994k ) \|\| (1.04M c >= 0x1d4a91.04M && c <= 0x1d4ac994k ) \|\| (1.04M c >= 0x1d4ae1.04M && c <= 0x1d4b9994k )
333	1.11M	\|\| c == 0x1d4bb1.04M \|\| (1.04M c >= 0x1d4bd1.04M && c <= 0x1d4c3994k ) \|\| (1.04M c >= 0x1d4c51.04M && c <= 0x1d505994k ) \|\| (1.04M c >= 0x1d5071.04M && c <= 0x1d50a994k )
334	1.11M	\|\| (1.04M c >= 0x1d50d1.04M && c <= 0x1d514994k ) \|\| (1.04M c >= 0x1d5161.04M && c <= 0x1d51c994k ) \|\| (1.04M c >= 0x1d51e1.04M && c <= 0x1d539994k ) \|\| (1.04M c >= 0x1d53b1.04M && c <= 0x1d53e993k )
335	1.11M	\|\| (1.04M c >= 0x1d5401.04M && c <= 0x1d544993k ) \|\| c == 0x1d5461.04M \|\| (1.04M c >= 0x1d54a1.04M && c <= 0x1d550993k ) \|\| (1.04M c >= 0x1d5521.04M && c <= 0x1d6a5993k )
336	1.11M	\|\| (1.04M c >= 0x1d6a81.04M && c <= 0x1d6c0993k ) \|\| (1.04M c >= 0x1d6c21.04M && c <= 0x1d6da993k ) \|\| (1.04M c >= 0x1d6dc1.04M && c <= 0x1d6fa993k ) \|\| (1.04M c >= 0x1d6fc1.04M && c <= 0x1d714993k )
337	1.11M	\|\| (1.04M c >= 0x1d7161.04M && c <= 0x1d734993k ) \|\| (1.04M c >= 0x1d7361.04M && c <= 0x1d74e993k ) \|\| (1.04M c >= 0x1d7501.04M && c <= 0x1d76e993k ) \|\| (1.04M c >= 0x1d7701.04M && c <= 0x1d788993k )
338	1.11M	\|\| (1.04M c >= 0x1d78a1.04M && c <= 0x1d7a8993k ) \|\| (1.04M c >= 0x1d7aa1.04M && c <= 0x1d7c2993k ) \|\| (1.04M c >= 0x1d7c41.04M && c <= 0x1d7cb993k ) \|\| (1.04M c >= 0x1d7ce1.04M && c <= 0x1d7ff993k )
339	1.11M	\|\| (1.04M c >= 0x1da001.04M && c <= 0x1da36992k ) \|\| (1.04M c >= 0x1da3b1.04M && c <= 0x1da6c992k ) \|\| c == 0x1da751.04M \|\| c == 0x1da841.04M
340	1.11M	\|\| (1.04M c >= 0x1da9b1.04M && c <= 0x1da9f992k ) \|\| (1.04M c >= 0x1daa11.04M && c <= 0x1daaf992k ) \|\| (1.04M c >= 0x1e0001.04M && c <= 0x1e006991k ) \|\| (1.04M c >= 0x1e0081.04M && c <= 0x1e018991k )
341	1.11M	\|\| (1.04M c >= 0x1e01b1.04M && c <= 0x1e021991k ) \|\| (1.04M c >= 0x1e0231.04M && c <= 0x1e024991k ) \|\| (1.04M c >= 0x1e0261.04M && c <= 0x1e02a991k ) \|\| (1.04M c >= 0x1e8001.04M && c <= 0x1e8c4989k )
342	1.11M	\|\| (1.04M c >= 0x1e8d01.04M && c <= 0x1e8d6988k ) \|\| (1.04M c >= 0x1e9001.04M && c <= 0x1e94a988k ) \|\| (1.04M c >= 0x1e9501.04M && c <= 0x1e959988k ) \|\| (1.04M c >= 0x1ee001.04M && c <= 0x1ee03987k )
343	1.11M	\|\| (1.04M c >= 0x1ee051.04M && c <= 0x1ee1f987k ) \|\| (1.04M c >= 0x1ee211.04M && c <= 0x1ee22987k ) \|\| c == 0x1ee241.04M \|\| c == 0x1ee271.04M
344	1.11M	\|\| (1.04M c >= 0x1ee291.04M && c <= 0x1ee32987k ) \|\| (1.04M c >= 0x1ee341.04M && c <= 0x1ee37987k ) \|\| c == 0x1ee391.04M \|\| c == 0x1ee3b1.04M
345	1.11M	\|\| c == 0x1ee421.04M \|\| c == 0x1ee471.04M \|\| c == 0x1ee491.04M \|\| c == 0x1ee4b1.04M
346	1.11M	\|\| (1.04M c >= 0x1ee4d1.04M && c <= 0x1ee4f987k ) \|\| (1.04M c >= 0x1ee511.04M && c <= 0x1ee52987k ) \|\| c == 0x1ee541.04M \|\| c == 0x1ee571.04M
347	1.11M	\|\| c == 0x1ee591.04M \|\| c == 0x1ee5b1.04M \|\| c == 0x1ee5d1.04M \|\| c == 0x1ee5f1.04M
348	1.11M	\|\| (1.04M c >= 0x1ee611.04M && c <= 0x1ee62987k ) \|\| c == 0x1ee641.04M \|\| (1.04M c >= 0x1ee671.04M && c <= 0x1ee6a987k ) \|\| (1.04M c >= 0x1ee6c1.04M && c <= 0x1ee72987k )
349	1.11M	\|\| (1.04M c >= 0x1ee741.04M && c <= 0x1ee77987k ) \|\| (1.04M c >= 0x1ee791.04M && c <= 0x1ee7c987k ) \|\| c == 0x1ee7e1.04M \|\| (1.04M c >= 0x1ee801.04M && c <= 0x1ee89987k )
350	1.11M	\|\| (1.04M c >= 0x1ee8b1.04M && c <= 0x1ee9b987k ) \|\| (1.04M c >= 0x1eea11.04M && c <= 0x1eea3987k ) \|\| (1.04M c >= 0x1eea51.04M && c <= 0x1eea9987k ) \|\| (1.04M c >= 0x1eeab1.04M && c <= 0x1eebb987k )
351	1.11M	\|\| (1.04M c >= 0x200001.04M && c <= 0x2a6d6983k ) \|\| (1.00M c >= 0x2a7001.00M && c <= 0x2b734940k ) \|\| (1.00M c >= 0x2b7401.00M && c <= 0x2b81d936k ) \|\| (1.00M c >= 0x2b8201.00M && c <= 0x2cea1935k )
352	1.11M	\|\| (994k c >= 0x2ceb0994k && c <= 0x2ebe0930k ) \|\| (986k c >= 0x2f800986k && c <= 0x2fa1d919k ) \|\| (986k c >= 0xe0100986k && c <= 0xe01ef196k );
353	1.11M	}
354
355	1.11M	bool isDigit(char32_t c) {
356	1.11M	return c >= '0' && c <= '9'1.11M ;
357	1.11M	}
358
359	1.11M	bool isHexDigit(char32_t c) {
360	1.11M	return (c >= '0' && c <= '9'1.11M )
361	1.11M	\|\| (1.11M c >= 'A'1.11M && c <= 'F'1.11M )
362	1.11M	\|\| (1.11M c >= 'a'1.11M && c <= 'f'1.11M );
363	1.11M	}
364
365		} // namespace util