/*

 * Copyright (c) 2016-2025  Moddable Tech, Inc.

 *

 *   This file is part of the Moddable SDK Runtime.

 * 

 *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as published by

 *   the Free Software Foundation, either version 3 of the License, or

 *   (at your option) any later version.

 * 

 *   The Moddable SDK Runtime is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 * 

 *   You should have received a copy of the GNU Lesser General Public License

 *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "xsAll.h"

//#define mxTrace 1

// COMMON

typedef struct {

  txU2 code; 

  txU1 count; 

  txU1 operand;

  txU2 delta;

} txCharCase;

static txInteger fxCharCaseCanonicalize(txInteger character, txBoolean flag);

static int fxCharCaseCompare(const void *p1, const void *p2);

enum {

  cxMatchStep,

  cxAssertionStep,

  cxAssertionCompletion,

  cxAssertionNotStep,

  cxAssertionNotCompletion,

  cxCaptureForwardStep,

  cxCaptureForwardCompletion,

  cxCaptureBackwardStep,

  cxCaptureBackwardCompletion,

  cxCaptureReferenceForwardStep,

  cxCaptureReferenceBackwardStep,

  cxCharSetForwardStep,

  cxCharSetBackwardStep,

  cxDisjunctionStep,

  cxEmptyStep,

  cxLineBeginStep,

  cxLineEndStep,

  cxQuantifierStep,

  cxQuantifierGreedyLoop,

  cxQuantifierLazyLoop,

  cxQuantifierCompletion,

  cxWordBreakStep,

  cxWordContinueStep,

  cxModifiersStep

};

typedef txInteger (*txConditionalCharCase)(txMachine*, txInteger, txInteger);

static txInteger fxFinalSigmaToLower(txMachine* the, txInteger where, txInteger character);

#define mxConditionalCharCaseToLowerCount 1

const txConditionalCharCase gxConditionalCharCaseToLower[mxConditionalCharCaseToLowerCount] ICACHE_XS6RO_ATTR = {

  fxFinalSigmaToLower,

};

#define mxConditionalCharCaseToUpperCount 0

const txConditionalCharCase* gxConditionalCharCaseToUpper = C_NULL;

#define mxCharCaseFold0Count 200

const txCharCase gxCharCaseFold0[mxCharCaseFold0Count] ICACHE_XS6RO_ATTR = {

  {0x0041,0x1A,0x40,0x0020},{0x00B5,0x01,0x40,0x0307},{0x00C0,0x17,0x40,0x0020},{0x00D8,0x07,0x40,0x0020},{0x0100,0x2F,0x60,0x0001},{0x0132,0x05,0x60,0x0001},{0x0139,0x0F,0x50,0x0001},{0x014A,0x2D,0x60,0x0001},

  {0x0178,0x01,0x80,0x0079},{0x0179,0x05,0x50,0x0001},{0x017F,0x01,0x80,0x010C},{0x0181,0x01,0x40,0x00D2},{0x0182,0x03,0x60,0x0001},{0x0186,0x01,0x40,0x00CE},{0x0187,0x01,0x50,0x0001},{0x0189,0x02,0x40,0x00CD},

  {0x018B,0x01,0x50,0x0001},{0x018E,0x01,0x40,0x004F},{0x018F,0x01,0x40,0x00CA},{0x0190,0x01,0x40,0x00CB},{0x0191,0x01,0x50,0x0001},{0x0193,0x01,0x40,0x00CD},{0x0194,0x01,0x40,0x00CF},{0x0196,0x01,0x40,0x00D3},

  {0x0197,0x01,0x40,0x00D1},{0x0198,0x01,0x60,0x0001},{0x019C,0x01,0x40,0x00D3},{0x019D,0x01,0x40,0x00D5},{0x019F,0x01,0x40,0x00D6},{0x01A0,0x05,0x60,0x0001},{0x01A6,0x01,0x40,0x00DA},{0x01A7,0x01,0x50,0x0001},

  {0x01A9,0x01,0x40,0x00DA},{0x01AC,0x01,0x60,0x0001},{0x01AE,0x01,0x40,0x00DA},{0x01AF,0x01,0x50,0x0001},{0x01B1,0x02,0x40,0x00D9},{0x01B3,0x03,0x50,0x0001},{0x01B7,0x01,0x40,0x00DB},{0x01B8,0x01,0x60,0x0001},

  {0x01BC,0x01,0x60,0x0001},{0x01C4,0x01,0x40,0x0002},{0x01C5,0x01,0x50,0x0001},{0x01C7,0x01,0x40,0x0002},{0x01C8,0x01,0x60,0x0001},{0x01CA,0x01,0x40,0x0002},{0x01CB,0x11,0x50,0x0001},{0x01DE,0x11,0x60,0x0001},

  {0x01F1,0x01,0x40,0x0002},{0x01F2,0x03,0x60,0x0001},{0x01F6,0x01,0x80,0x0061},{0x01F7,0x01,0x80,0x0038},{0x01F8,0x27,0x60,0x0001},{0x0220,0x01,0x80,0x0082},{0x0222,0x11,0x60,0x0001},{0x023A,0x01,0x40,0x2A2B},

  {0x023B,0x01,0x50,0x0001},{0x023D,0x01,0x80,0x00A3},{0x023E,0x01,0x40,0x2A28},{0x0241,0x01,0x50,0x0001},{0x0243,0x01,0x80,0x00C3},{0x0244,0x01,0x40,0x0045},{0x0245,0x01,0x40,0x0047},{0x0246,0x09,0x60,0x0001},

  {0x0345,0x01,0x40,0x0074},{0x0370,0x03,0x60,0x0001},{0x0376,0x01,0x60,0x0001},{0x037F,0x01,0x40,0x0074},{0x0386,0x01,0x40,0x0026},{0x0388,0x03,0x40,0x0025},{0x038C,0x01,0x40,0x0040},{0x038E,0x02,0x40,0x003F},

  {0x0391,0x11,0x40,0x0020},{0x03A3,0x09,0x40,0x0020},{0x03C2,0x01,0x60,0x0001},{0x03CF,0x01,0x40,0x0008},{0x03D0,0x01,0x80,0x001E},{0x03D1,0x01,0x80,0x0019},{0x03D5,0x01,0x80,0x000F},{0x03D6,0x01,0x80,0x0016},

  {0x03D8,0x17,0x60,0x0001},{0x03F0,0x01,0x80,0x0036},{0x03F1,0x01,0x80,0x0030},{0x03F4,0x01,0x80,0x003C},{0x03F5,0x01,0x80,0x0040},{0x03F7,0x01,0x50,0x0001},{0x03F9,0x01,0x80,0x0007},{0x03FA,0x01,0x60,0x0001},

  {0x03FD,0x03,0x80,0x0082},{0x0400,0x10,0x40,0x0050},{0x0410,0x20,0x40,0x0020},{0x0460,0x21,0x60,0x0001},{0x048A,0x35,0x60,0x0001},{0x04C0,0x01,0x40,0x000F},{0x04C1,0x0D,0x50,0x0001},{0x04D0,0x5F,0x60,0x0001},

  {0x0531,0x26,0x40,0x0030},{0x10A0,0x26,0x40,0x1C60},{0x10C7,0x01,0x40,0x1C60},{0x10CD,0x01,0x40,0x1C60},{0x13F8,0x06,0x80,0x0008},{0x1C80,0x01,0x80,0x184E},{0x1C81,0x01,0x80,0x184D},{0x1C82,0x01,0x80,0x1844},

  {0x1C83,0x02,0x80,0x1842},{0x1C85,0x01,0x80,0x1843},{0x1C86,0x01,0x80,0x183C},{0x1C87,0x01,0x80,0x1824},{0x1C88,0x01,0x40,0x89C3},{0x1C89,0x01,0x50,0x0001},{0x1C90,0x2B,0x80,0x0BC0},{0x1CBD,0x03,0x80,0x0BC0},

  {0x1E00,0x95,0x60,0x0001},{0x1E9B,0x01,0x80,0x003A},{0x1E9E,0x01,0x80,0x1DBF},{0x1EA0,0x5F,0x60,0x0001},{0x1F08,0x08,0x80,0x0008},{0x1F18,0x06,0x80,0x0008},{0x1F28,0x08,0x80,0x0008},{0x1F38,0x08,0x80,0x0008},

  {0x1F48,0x06,0x80,0x0008},{0x1F59,0x01,0x80,0x0008},{0x1F5B,0x01,0x80,0x0008},{0x1F5D,0x01,0x80,0x0008},{0x1F5F,0x01,0x80,0x0008},{0x1F68,0x08,0x80,0x0008},{0x1F88,0x08,0x80,0x0008},{0x1F98,0x08,0x80,0x0008},

  {0x1FA8,0x08,0x80,0x0008},{0x1FB8,0x02,0x80,0x0008},{0x1FBA,0x02,0x80,0x004A},{0x1FBC,0x01,0x80,0x0009},{0x1FBE,0x01,0x80,0x1C05},{0x1FC8,0x04,0x80,0x0056},{0x1FCC,0x01,0x80,0x0009},{0x1FD3,0x01,0x80,0x1C43},

  {0x1FD8,0x02,0x80,0x0008},{0x1FDA,0x02,0x80,0x0064},{0x1FE3,0x01,0x80,0x1C33},{0x1FE8,0x02,0x80,0x0008},{0x1FEA,0x02,0x80,0x0070},{0x1FEC,0x01,0x80,0x0007},{0x1FF8,0x02,0x80,0x0080},{0x1FFA,0x02,0x80,0x007E},

  {0x1FFC,0x01,0x80,0x0009},{0x2126,0x01,0x80,0x1D5D},{0x212A,0x01,0x80,0x20BF},{0x212B,0x01,0x80,0x2046},{0x2132,0x01,0x40,0x001C},{0x2160,0x10,0x40,0x0010},{0x2183,0x01,0x50,0x0001},{0x24B6,0x1A,0x40,0x001A},

  {0x2C00,0x30,0x40,0x0030},{0x2C60,0x01,0x60,0x0001},{0x2C62,0x01,0x80,0x29F7},{0x2C63,0x01,0x80,0x0EE6},{0x2C64,0x01,0x80,0x29E7},{0x2C67,0x05,0x50,0x0001},{0x2C6D,0x01,0x80,0x2A1C},{0x2C6E,0x01,0x80,0x29FD},

  {0x2C6F,0x01,0x80,0x2A1F},{0x2C70,0x01,0x80,0x2A1E},{0x2C72,0x01,0x60,0x0001},{0x2C75,0x01,0x50,0x0001},{0x2C7E,0x02,0x80,0x2A3F},{0x2C80,0x63,0x60,0x0001},{0x2CEB,0x03,0x50,0x0001},{0x2CF2,0x01,0x60,0x0001},

  {0xA640,0x2D,0x60,0x0001},{0xA680,0x1B,0x60,0x0001},{0xA722,0x0D,0x60,0x0001},{0xA732,0x3D,0x60,0x0001},{0xA779,0x03,0x50,0x0001},{0xA77D,0x01,0x80,0x8A04},{0xA77E,0x09,0x60,0x0001},{0xA78B,0x01,0x50,0x0001},

  {0xA78D,0x01,0x80,0xA528},{0xA790,0x03,0x60,0x0001},{0xA796,0x13,0x60,0x0001},{0xA7AA,0x01,0x80,0xA544},{0xA7AB,0x01,0x80,0xA54F},{0xA7AC,0x01,0x80,0xA54B},{0xA7AD,0x01,0x80,0xA541},{0xA7AE,0x01,0x80,0xA544},

  {0xA7B0,0x01,0x80,0xA512},{0xA7B1,0x01,0x80,0xA52A},{0xA7B2,0x01,0x80,0xA515},{0xA7B3,0x01,0x40,0x03A0},{0xA7B4,0x0F,0x60,0x0001},{0xA7C4,0x01,0x80,0x0030},{0xA7C5,0x01,0x80,0xA543},{0xA7C6,0x01,0x80,0x8A38},

  {0xA7C7,0x03,0x50,0x0001},{0xA7CB,0x01,0x80,0xA567},{0xA7CC,0x0F,0x60,0x0001},{0xA7DC,0x01,0x80,0xA641},{0xA7F5,0x01,0x50,0x0001},{0xAB70,0x50,0x80,0x97D0},{0xFB05,0x01,0x50,0x0001},{0xFF21,0x1A,0x40,0x0020},

};

#define mxCharCaseFold1Count 12

const txCharCase gxCharCaseFold1[mxCharCaseFold1Count] ICACHE_XS6RO_ATTR = {

  {0x0400,0x28,0x40,0x0028},{0x04B0,0x24,0x40,0x0028},{0x0570,0x0B,0x40,0x0027},{0x057C,0x0F,0x40,0x0027},{0x058C,0x07,0x40,0x0027},{0x0594,0x02,0x40,0x0027},{0x0C80,0x33,0x40,0x0040},{0x0D50,0x16,0x40,0x0020},

  {0x18A0,0x20,0x40,0x0020},{0x6E40,0x20,0x40,0x0020},{0x6EA0,0x19,0x40,0x001B},{0xE900,0x22,0x40,0x0022},

};

#define mxCharCaseIgnore0Count 193

const txCharCase gxCharCaseIgnore0[mxCharCaseIgnore0Count] ICACHE_XS6RO_ATTR = {

  {0x0061,0x1A,0x80,0x0020},{0x00B5,0x01,0x40,0x02E7},{0x00E0,0x17,0x80,0x0020},{0x00F8,0x07,0x80,0x0020},{0x00FF,0x01,0x40,0x0079},{0x0101,0x2F,0x90,0x0001},{0x0133,0x05,0x90,0x0001},{0x013A,0x0F,0xA0,0x0001},

  {0x014B,0x2D,0x90,0x0001},{0x017A,0x05,0xA0,0x0001},{0x0180,0x01,0x40,0x00C3},{0x0183,0x03,0x90,0x0001},{0x0188,0x01,0xA0,0x0001},{0x018C,0x01,0xA0,0x0001},{0x0192,0x01,0xA0,0x0001},{0x0195,0x01,0x40,0x0061},

  {0x0199,0x01,0x90,0x0001},{0x019A,0x01,0x40,0x00A3},{0x019B,0x01,0x40,0xA641},{0x019E,0x01,0x40,0x0082},{0x01A1,0x05,0x90,0x0001},{0x01A8,0x01,0xA0,0x0001},{0x01AD,0x01,0x90,0x0001},{0x01B0,0x01,0xA0,0x0001},

  {0x01B4,0x03,0xA0,0x0001},{0x01B9,0x01,0x90,0x0001},{0x01BD,0x01,0x90,0x0001},{0x01BF,0x01,0x40,0x0038},{0x01C5,0x01,0x90,0x0001},{0x01C6,0x01,0x80,0x0002},{0x01C8,0x01,0xA0,0x0001},{0x01C9,0x01,0x80,0x0002},

  {0x01CB,0x01,0x90,0x0001},{0x01CC,0x01,0x80,0x0002},{0x01CE,0x0F,0xA0,0x0001},{0x01DD,0x01,0x80,0x004F},{0x01DF,0x11,0x90,0x0001},{0x01F2,0x01,0xA0,0x0001},{0x01F3,0x01,0x80,0x0002},{0x01F5,0x01,0x90,0x0001},

  {0x01F9,0x27,0x90,0x0001},{0x0223,0x11,0x90,0x0001},{0x023C,0x01,0xA0,0x0001},{0x023F,0x02,0x40,0x2A3F},{0x0242,0x01,0xA0,0x0001},{0x0247,0x09,0x90,0x0001},{0x0250,0x01,0x40,0x2A1F},{0x0251,0x01,0x40,0x2A1C},

  {0x0252,0x01,0x40,0x2A1E},{0x0253,0x01,0x80,0x00D2},{0x0254,0x01,0x80,0x00CE},{0x0256,0x02,0x80,0x00CD},{0x0259,0x01,0x80,0x00CA},{0x025B,0x01,0x80,0x00CB},{0x025C,0x01,0x40,0xA54F},{0x0260,0x01,0x80,0x00CD},

  {0x0261,0x01,0x40,0xA54B},{0x0263,0x01,0x80,0x00CF},{0x0264,0x01,0x40,0xA567},{0x0265,0x01,0x40,0xA528},{0x0266,0x01,0x40,0xA544},{0x0268,0x01,0x80,0x00D1},{0x0269,0x01,0x80,0x00D3},{0x026A,0x01,0x40,0xA544},

  {0x026B,0x01,0x40,0x29F7},{0x026C,0x01,0x40,0xA541},{0x026F,0x01,0x80,0x00D3},{0x0271,0x01,0x40,0x29FD},{0x0272,0x01,0x80,0x00D5},{0x0275,0x01,0x80,0x00D6},{0x027D,0x01,0x40,0x29E7},{0x0280,0x01,0x80,0x00DA},

  {0x0282,0x01,0x40,0xA543},{0x0283,0x01,0x80,0x00DA},{0x0287,0x01,0x40,0xA52A},{0x0288,0x01,0x80,0x00DA},{0x0289,0x01,0x80,0x0045},{0x028A,0x02,0x80,0x00D9},{0x028C,0x01,0x80,0x0047},{0x0292,0x01,0x80,0x00DB},

  {0x029D,0x01,0x40,0xA515},{0x029E,0x01,0x40,0xA512},{0x0345,0x01,0x40,0x0054},{0x0371,0x03,0x90,0x0001},{0x0377,0x01,0x90,0x0001},{0x037B,0x03,0x40,0x0082},{0x03AC,0x01,0x80,0x0026},{0x03AD,0x03,0x80,0x0025},

  {0x03B1,0x11,0x80,0x0020},{0x03C2,0x01,0x80,0x001F},{0x03C3,0x09,0x80,0x0020},{0x03CC,0x01,0x80,0x0040},{0x03CD,0x02,0x80,0x003F},{0x03D0,0x01,0x80,0x003E},{0x03D1,0x01,0x80,0x0039},{0x03D5,0x01,0x80,0x002F},

  {0x03D6,0x01,0x80,0x0036},{0x03D7,0x01,0x80,0x0008},{0x03D9,0x17,0x90,0x0001},{0x03F0,0x01,0x80,0x0056},{0x03F1,0x01,0x80,0x0050},{0x03F2,0x01,0x40,0x0007},{0x03F3,0x01,0x80,0x0074},{0x03F5,0x01,0x80,0x0060},

  {0x03F8,0x01,0xA0,0x0001},{0x03FB,0x01,0x90,0x0001},{0x0430,0x20,0x80,0x0020},{0x0450,0x10,0x80,0x0050},{0x0461,0x21,0x90,0x0001},{0x048B,0x35,0x90,0x0001},{0x04C2,0x0D,0xA0,0x0001},{0x04CF,0x01,0x80,0x000F},

  {0x04D1,0x5F,0x90,0x0001},{0x0561,0x26,0x80,0x0030},{0x10D0,0x2B,0x40,0x0BC0},{0x10FD,0x03,0x40,0x0BC0},{0x13F8,0x06,0x80,0x0008},{0x1C80,0x01,0x80,0x186E},{0x1C81,0x01,0x80,0x186D},{0x1C82,0x01,0x80,0x1864},

  {0x1C83,0x02,0x80,0x1862},{0x1C85,0x01,0x80,0x1863},{0x1C86,0x01,0x80,0x185C},{0x1C87,0x01,0x80,0x1825},{0x1C88,0x01,0x40,0x89C2},{0x1C8A,0x01,0xA0,0x0001},{0x1D79,0x01,0x40,0x8A04},{0x1D7D,0x01,0x40,0x0EE6},

  {0x1D8E,0x01,0x40,0x8A38},{0x1E01,0x95,0x90,0x0001},{0x1E9B,0x01,0x80,0x003B},{0x1EA1,0x5F,0x90,0x0001},{0x1F00,0x08,0x40,0x0008},{0x1F10,0x06,0x40,0x0008},{0x1F20,0x08,0x40,0x0008},{0x1F30,0x08,0x40,0x0008},

  {0x1F40,0x06,0x40,0x0008},{0x1F51,0x01,0x40,0x0008},{0x1F53,0x01,0x40,0x0008},{0x1F55,0x01,0x40,0x0008},{0x1F57,0x01,0x40,0x0008},{0x1F60,0x08,0x40,0x0008},{0x1F70,0x02,0x40,0x004A},{0x1F72,0x04,0x40,0x0056},

  {0x1F76,0x02,0x40,0x0064},{0x1F78,0x02,0x40,0x0080},{0x1F7A,0x02,0x40,0x0070},{0x1F7C,0x02,0x40,0x007E},{0x1F80,0x08,0x40,0x0008},{0x1F90,0x08,0x40,0x0008},{0x1FA0,0x08,0x40,0x0008},{0x1FB0,0x02,0x40,0x0008},

  {0x1FB3,0x01,0x40,0x0009},{0x1FBE,0x01,0x80,0x1C25},{0x1FC3,0x01,0x40,0x0009},{0x1FD0,0x02,0x40,0x0008},{0x1FE0,0x02,0x40,0x0008},{0x1FE5,0x01,0x40,0x0007},{0x1FF3,0x01,0x40,0x0009},{0x214E,0x01,0x80,0x001C},

  {0x2170,0x10,0x80,0x0010},{0x2184,0x01,0xA0,0x0001},{0x24D0,0x1A,0x80,0x001A},{0x2C30,0x30,0x80,0x0030},{0x2C61,0x01,0x90,0x0001},{0x2C65,0x01,0x80,0x2A2B},{0x2C66,0x01,0x80,0x2A28},{0x2C68,0x05,0xA0,0x0001},

  {0x2C73,0x01,0x90,0x0001},{0x2C76,0x01,0xA0,0x0001},{0x2C81,0x63,0x90,0x0001},{0x2CEC,0x03,0xA0,0x0001},{0x2CF3,0x01,0x90,0x0001},{0x2D00,0x26,0x80,0x1C60},{0x2D27,0x01,0x80,0x1C60},{0x2D2D,0x01,0x80,0x1C60},

  {0xA641,0x2D,0x90,0x0001},{0xA681,0x1B,0x90,0x0001},{0xA723,0x0D,0x90,0x0001},{0xA733,0x3D,0x90,0x0001},{0xA77A,0x03,0xA0,0x0001},{0xA77F,0x09,0x90,0x0001},{0xA78C,0x01,0xA0,0x0001},{0xA791,0x03,0x90,0x0001},

  {0xA794,0x01,0x40,0x0030},{0xA797,0x13,0x90,0x0001},{0xA7B5,0x0F,0x90,0x0001},{0xA7C8,0x03,0xA0,0x0001},{0xA7CD,0x0F,0x90,0x0001},{0xA7F6,0x01,0xA0,0x0001},{0xAB53,0x01,0x80,0x03A0},{0xAB70,0x50,0x80,0x97D0},

  {0xFF41,0x1A,0x80,0x0020},

};

#define mxSpecialCharCaseToLowerCount 2

const txInteger gxSpecialCharCaseToLower[mxSpecialCharCaseToLowerCount] ICACHE_XS6RO_ATTR = {

  0x69,0x307,

};

#define mxCharCaseToLower0Count 178

const txCharCase gxCharCaseToLower0[mxCharCaseToLower0Count] ICACHE_XS6RO_ATTR = {

  {0x0041,0x1A,0x40,0x0020},{0x00C0,0x17,0x40,0x0020},{0x00D8,0x07,0x40,0x0020},{0x0100,0x2F,0x60,0x0001},{0x0130,0x01,0x02,0x0000},{0x0132,0x05,0x60,0x0001},{0x0139,0x0F,0x50,0x0001},{0x014A,0x2D,0x60,0x0001},

  {0x0178,0x01,0x80,0x0079},{0x0179,0x05,0x50,0x0001},{0x0181,0x01,0x40,0x00D2},{0x0182,0x03,0x60,0x0001},{0x0186,0x01,0x40,0x00CE},{0x0187,0x01,0x50,0x0001},{0x0189,0x02,0x40,0x00CD},{0x018B,0x01,0x50,0x0001},

  {0x018E,0x01,0x40,0x004F},{0x018F,0x01,0x40,0x00CA},{0x0190,0x01,0x40,0x00CB},{0x0191,0x01,0x50,0x0001},{0x0193,0x01,0x40,0x00CD},{0x0194,0x01,0x40,0x00CF},{0x0196,0x01,0x40,0x00D3},{0x0197,0x01,0x40,0x00D1},

  {0x0198,0x01,0x60,0x0001},{0x019C,0x01,0x40,0x00D3},{0x019D,0x01,0x40,0x00D5},{0x019F,0x01,0x40,0x00D6},{0x01A0,0x05,0x60,0x0001},{0x01A6,0x01,0x40,0x00DA},{0x01A7,0x01,0x50,0x0001},{0x01A9,0x01,0x40,0x00DA},

  {0x01AC,0x01,0x60,0x0001},{0x01AE,0x01,0x40,0x00DA},{0x01AF,0x01,0x50,0x0001},{0x01B1,0x02,0x40,0x00D9},{0x01B3,0x03,0x50,0x0001},{0x01B7,0x01,0x40,0x00DB},{0x01B8,0x01,0x60,0x0001},{0x01BC,0x01,0x60,0x0001},

  {0x01C4,0x01,0x40,0x0002},{0x01C5,0x01,0x50,0x0001},{0x01C7,0x01,0x40,0x0002},{0x01C8,0x01,0x60,0x0001},{0x01CA,0x01,0x40,0x0002},{0x01CB,0x11,0x50,0x0001},{0x01DE,0x11,0x60,0x0001},{0x01F1,0x01,0x40,0x0002},

  {0x01F2,0x03,0x60,0x0001},{0x01F6,0x01,0x80,0x0061},{0x01F7,0x01,0x80,0x0038},{0x01F8,0x27,0x60,0x0001},{0x0220,0x01,0x80,0x0082},{0x0222,0x11,0x60,0x0001},{0x023A,0x01,0x40,0x2A2B},{0x023B,0x01,0x50,0x0001},

  {0x023D,0x01,0x80,0x00A3},{0x023E,0x01,0x40,0x2A28},{0x0241,0x01,0x50,0x0001},{0x0243,0x01,0x80,0x00C3},{0x0244,0x01,0x40,0x0045},{0x0245,0x01,0x40,0x0047},{0x0246,0x09,0x60,0x0001},{0x0370,0x03,0x60,0x0001},

  {0x0376,0x01,0x60,0x0001},{0x037F,0x01,0x40,0x0074},{0x0386,0x01,0x40,0x0026},{0x0388,0x03,0x40,0x0025},{0x038C,0x01,0x40,0x0040},{0x038E,0x02,0x40,0x003F},{0x0391,0x11,0x40,0x0020},{0x03A3,0x01,0x00,0x0000},

  {0x03A4,0x08,0x40,0x0020},{0x03CF,0x01,0x40,0x0008},{0x03D8,0x17,0x60,0x0001},{0x03F4,0x01,0x80,0x003C},{0x03F7,0x01,0x50,0x0001},{0x03F9,0x01,0x80,0x0007},{0x03FA,0x01,0x60,0x0001},{0x03FD,0x03,0x80,0x0082},

  {0x0400,0x10,0x40,0x0050},{0x0410,0x20,0x40,0x0020},{0x0460,0x21,0x60,0x0001},{0x048A,0x35,0x60,0x0001},{0x04C0,0x01,0x40,0x000F},{0x04C1,0x0D,0x50,0x0001},{0x04D0,0x5F,0x60,0x0001},{0x0531,0x26,0x40,0x0030},

  {0x10A0,0x26,0x40,0x1C60},{0x10C7,0x01,0x40,0x1C60},{0x10CD,0x01,0x40,0x1C60},{0x13A0,0x50,0x40,0x97D0},{0x13F0,0x06,0x40,0x0008},{0x1C89,0x01,0x50,0x0001},{0x1C90,0x2B,0x80,0x0BC0},{0x1CBD,0x03,0x80,0x0BC0},

  {0x1E00,0x95,0x60,0x0001},{0x1E9E,0x01,0x80,0x1DBF},{0x1EA0,0x5F,0x60,0x0001},{0x1F08,0x08,0x80,0x0008},{0x1F18,0x06,0x80,0x0008},{0x1F28,0x08,0x80,0x0008},{0x1F38,0x08,0x80,0x0008},{0x1F48,0x06,0x80,0x0008},

  {0x1F59,0x01,0x80,0x0008},{0x1F5B,0x01,0x80,0x0008},{0x1F5D,0x01,0x80,0x0008},{0x1F5F,0x01,0x80,0x0008},{0x1F68,0x08,0x80,0x0008},{0x1F88,0x08,0x80,0x0008},{0x1F98,0x08,0x80,0x0008},{0x1FA8,0x08,0x80,0x0008},

  {0x1FB8,0x02,0x80,0x0008},{0x1FBA,0x02,0x80,0x004A},{0x1FBC,0x01,0x80,0x0009},{0x1FC8,0x04,0x80,0x0056},{0x1FCC,0x01,0x80,0x0009},{0x1FD8,0x02,0x80,0x0008},{0x1FDA,0x02,0x80,0x0064},{0x1FE8,0x02,0x80,0x0008},

  {0x1FEA,0x02,0x80,0x0070},{0x1FEC,0x01,0x80,0x0007},{0x1FF8,0x02,0x80,0x0080},{0x1FFA,0x02,0x80,0x007E},{0x1FFC,0x01,0x80,0x0009},{0x2126,0x01,0x80,0x1D5D},{0x212A,0x01,0x80,0x20BF},{0x212B,0x01,0x80,0x2046},

  {0x2132,0x01,0x40,0x001C},{0x2160,0x10,0x40,0x0010},{0x2183,0x01,0x50,0x0001},{0x24B6,0x1A,0x40,0x001A},{0x2C00,0x30,0x40,0x0030},{0x2C60,0x01,0x60,0x0001},{0x2C62,0x01,0x80,0x29F7},{0x2C63,0x01,0x80,0x0EE6},

  {0x2C64,0x01,0x80,0x29E7},{0x2C67,0x05,0x50,0x0001},{0x2C6D,0x01,0x80,0x2A1C},{0x2C6E,0x01,0x80,0x29FD},{0x2C6F,0x01,0x80,0x2A1F},{0x2C70,0x01,0x80,0x2A1E},{0x2C72,0x01,0x60,0x0001},{0x2C75,0x01,0x50,0x0001},

  {0x2C7E,0x02,0x80,0x2A3F},{0x2C80,0x63,0x60,0x0001},{0x2CEB,0x03,0x50,0x0001},{0x2CF2,0x01,0x60,0x0001},{0xA640,0x2D,0x60,0x0001},{0xA680,0x1B,0x60,0x0001},{0xA722,0x0D,0x60,0x0001},{0xA732,0x3D,0x60,0x0001},

  {0xA779,0x03,0x50,0x0001},{0xA77D,0x01,0x80,0x8A04},{0xA77E,0x09,0x60,0x0001},{0xA78B,0x01,0x50,0x0001},{0xA78D,0x01,0x80,0xA528},{0xA790,0x03,0x60,0x0001},{0xA796,0x13,0x60,0x0001},{0xA7AA,0x01,0x80,0xA544},

  {0xA7AB,0x01,0x80,0xA54F},{0xA7AC,0x01,0x80,0xA54B},{0xA7AD,0x01,0x80,0xA541},{0xA7AE,0x01,0x80,0xA544},{0xA7B0,0x01,0x80,0xA512},{0xA7B1,0x01,0x80,0xA52A},{0xA7B2,0x01,0x80,0xA515},{0xA7B3,0x01,0x40,0x03A0},

  {0xA7B4,0x0F,0x60,0x0001},{0xA7C4,0x01,0x80,0x0030},{0xA7C5,0x01,0x80,0xA543},{0xA7C6,0x01,0x80,0x8A38},{0xA7C7,0x03,0x50,0x0001},{0xA7CB,0x01,0x80,0xA567},{0xA7CC,0x0F,0x60,0x0001},{0xA7DC,0x01,0x80,0xA641},

  {0xA7F5,0x01,0x50,0x0001},{0xFF21,0x1A,0x40,0x0020},

};

#define mxCharCaseToLower1Count 12

const txCharCase gxCharCaseToLower1[mxCharCaseToLower1Count] ICACHE_XS6RO_ATTR = {

  {0x0400,0x28,0x40,0x0028},{0x04B0,0x24,0x40,0x0028},{0x0570,0x0B,0x40,0x0027},{0x057C,0x0F,0x40,0x0027},{0x058C,0x07,0x40,0x0027},{0x0594,0x02,0x40,0x0027},{0x0C80,0x33,0x40,0x0040},{0x0D50,0x16,0x40,0x0020},

  {0x18A0,0x20,0x40,0x0020},{0x6E40,0x20,0x40,0x0020},{0x6EA0,0x19,0x40,0x001B},{0xE900,0x22,0x40,0x0022},

};

#define mxSpecialCharCaseToUpperCount 220

const txInteger gxSpecialCharCaseToUpper[mxSpecialCharCaseToUpperCount] ICACHE_XS6RO_ATTR = {

  0x53,0x53,0x46,0x46,0x46,0x49,0x46,0x4c,0x46,0x46,0x49,0x46,0x46,0x4c,0x53,0x54,0x53,0x54,0x535,0x552,0x544,0x546,0x544,0x535,0x544,0x53b,0x54e,0x546,0x544,0x53d,0x2bc,0x4e,

  0x399,0x308,0x301,0x3a5,0x308,0x301,0x4a,0x30c,0x48,0x331,0x54,0x308,0x57,0x30a,0x59,0x30a,0x41,0x2be,0x3a5,0x313,0x3a5,0x313,0x300,0x3a5,0x313,0x301,0x3a5,0x313,0x342,0x391,0x342,0x397,

  0x342,0x399,0x308,0x300,0x399,0x308,0x301,0x399,0x342,0x399,0x308,0x342,0x3a5,0x308,0x300,0x3a5,0x308,0x301,0x3a1,0x313,0x3a5,0x342,0x3a5,0x308,0x342,0x3a9,0x342,0x1f08,0x399,0x1f09,0x399,0x1f0a,

  0x399,0x1f0b,0x399,0x1f0c,0x399,0x1f0d,0x399,0x1f0e,0x399,0x1f0f,0x399,0x1f08,0x399,0x1f09,0x399,0x1f0a,0x399,0x1f0b,0x399,0x1f0c,0x399,0x1f0d,0x399,0x1f0e,0x399,0x1f0f,0x399,0x1f28,0x399,0x1f29,0x399,0x1f2a,

  0x399,0x1f2b,0x399,0x1f2c,0x399,0x1f2d,0x399,0x1f2e,0x399,0x1f2f,0x399,0x1f28,0x399,0x1f29,0x399,0x1f2a,0x399,0x1f2b,0x399,0x1f2c,0x399,0x1f2d,0x399,0x1f2e,0x399,0x1f2f,0x399,0x1f68,0x399,0x1f69,0x399,0x1f6a,

  0x399,0x1f6b,0x399,0x1f6c,0x399,0x1f6d,0x399,0x1f6e,0x399,0x1f6f,0x399,0x1f68,0x399,0x1f69,0x399,0x1f6a,0x399,0x1f6b,0x399,0x1f6c,0x399,0x1f6d,0x399,0x1f6e,0x399,0x1f6f,0x399,0x391,0x399,0x391,0x399,0x397,

  0x399,0x397,0x399,0x3a9,0x399,0x3a9,0x399,0x1fba,0x399,0x386,0x399,0x1fca,0x399,0x389,0x399,0x1ffa,0x399,0x38f,0x399,0x391,0x342,0x399,0x397,0x342,0x399,0x3a9,0x342,0x399,

};

#define mxCharCaseToUpper0Count 291

const txCharCase gxCharCaseToUpper0[mxCharCaseToUpper0Count] ICACHE_XS6RO_ATTR = {

  {0x0061,0x1A,0x80,0x0020},{0x00B5,0x01,0x40,0x02E7},{0x00DF,0x01,0x02,0x0000},{0x00E0,0x17,0x80,0x0020},{0x00F8,0x07,0x80,0x0020},{0x00FF,0x01,0x40,0x0079},{0x0101,0x2F,0x90,0x0001},{0x0131,0x01,0x80,0x00E8},

  {0x0133,0x05,0x90,0x0001},{0x013A,0x0F,0xA0,0x0001},{0x0149,0x01,0x02,0x001E},{0x014B,0x2D,0x90,0x0001},{0x017A,0x05,0xA0,0x0001},{0x017F,0x01,0x80,0x012C},{0x0180,0x01,0x40,0x00C3},{0x0183,0x03,0x90,0x0001},

  {0x0188,0x01,0xA0,0x0001},{0x018C,0x01,0xA0,0x0001},{0x0192,0x01,0xA0,0x0001},{0x0195,0x01,0x40,0x0061},{0x0199,0x01,0x90,0x0001},{0x019A,0x01,0x40,0x00A3},{0x019B,0x01,0x40,0xA641},{0x019E,0x01,0x40,0x0082},

  {0x01A1,0x05,0x90,0x0001},{0x01A8,0x01,0xA0,0x0001},{0x01AD,0x01,0x90,0x0001},{0x01B0,0x01,0xA0,0x0001},{0x01B4,0x03,0xA0,0x0001},{0x01B9,0x01,0x90,0x0001},{0x01BD,0x01,0x90,0x0001},{0x01BF,0x01,0x40,0x0038},

  {0x01C5,0x01,0x90,0x0001},{0x01C6,0x01,0x80,0x0002},{0x01C8,0x01,0xA0,0x0001},{0x01C9,0x01,0x80,0x0002},{0x01CB,0x01,0x90,0x0001},{0x01CC,0x01,0x80,0x0002},{0x01CE,0x0F,0xA0,0x0001},{0x01DD,0x01,0x80,0x004F},

  {0x01DF,0x11,0x90,0x0001},{0x01F0,0x01,0x02,0x0026},{0x01F2,0x01,0xA0,0x0001},{0x01F3,0x01,0x80,0x0002},{0x01F5,0x01,0x90,0x0001},{0x01F9,0x27,0x90,0x0001},{0x0223,0x11,0x90,0x0001},{0x023C,0x01,0xA0,0x0001},

  {0x023F,0x02,0x40,0x2A3F},{0x0242,0x01,0xA0,0x0001},{0x0247,0x09,0x90,0x0001},{0x0250,0x01,0x40,0x2A1F},{0x0251,0x01,0x40,0x2A1C},{0x0252,0x01,0x40,0x2A1E},{0x0253,0x01,0x80,0x00D2},{0x0254,0x01,0x80,0x00CE},

  {0x0256,0x02,0x80,0x00CD},{0x0259,0x01,0x80,0x00CA},{0x025B,0x01,0x80,0x00CB},{0x025C,0x01,0x40,0xA54F},{0x0260,0x01,0x80,0x00CD},{0x0261,0x01,0x40,0xA54B},{0x0263,0x01,0x80,0x00CF},{0x0264,0x01,0x40,0xA567},

  {0x0265,0x01,0x40,0xA528},{0x0266,0x01,0x40,0xA544},{0x0268,0x01,0x80,0x00D1},{0x0269,0x01,0x80,0x00D3},{0x026A,0x01,0x40,0xA544},{0x026B,0x01,0x40,0x29F7},{0x026C,0x01,0x40,0xA541},{0x026F,0x01,0x80,0x00D3},

  {0x0271,0x01,0x40,0x29FD},{0x0272,0x01,0x80,0x00D5},{0x0275,0x01,0x80,0x00D6},{0x027D,0x01,0x40,0x29E7},{0x0280,0x01,0x80,0x00DA},{0x0282,0x01,0x40,0xA543},{0x0283,0x01,0x80,0x00DA},{0x0287,0x01,0x40,0xA52A},

  {0x0288,0x01,0x80,0x00DA},{0x0289,0x01,0x80,0x0045},{0x028A,0x02,0x80,0x00D9},{0x028C,0x01,0x80,0x0047},{0x0292,0x01,0x80,0x00DB},{0x029D,0x01,0x40,0xA515},{0x029E,0x01,0x40,0xA512},{0x0345,0x01,0x40,0x0054},

  {0x0371,0x03,0x90,0x0001},{0x0377,0x01,0x90,0x0001},{0x037B,0x03,0x40,0x0082},{0x0390,0x01,0x03,0x0020},{0x03AC,0x01,0x80,0x0026},{0x03AD,0x03,0x80,0x0025},{0x03B0,0x01,0x03,0x0023},{0x03B1,0x11,0x80,0x0020},

  {0x03C2,0x01,0x80,0x001F},{0x03C3,0x09,0x80,0x0020},{0x03CC,0x01,0x80,0x0040},{0x03CD,0x02,0x80,0x003F},{0x03D0,0x01,0x80,0x003E},{0x03D1,0x01,0x80,0x0039},{0x03D5,0x01,0x80,0x002F},{0x03D6,0x01,0x80,0x0036},

  {0x03D7,0x01,0x80,0x0008},{0x03D9,0x17,0x90,0x0001},{0x03F0,0x01,0x80,0x0056},{0x03F1,0x01,0x80,0x0050},{0x03F2,0x01,0x40,0x0007},{0x03F3,0x01,0x80,0x0074},{0x03F5,0x01,0x80,0x0060},{0x03F8,0x01,0xA0,0x0001},

  {0x03FB,0x01,0x90,0x0001},{0x0430,0x20,0x80,0x0020},{0x0450,0x10,0x80,0x0050},{0x0461,0x21,0x90,0x0001},{0x048B,0x35,0x90,0x0001},{0x04C2,0x0D,0xA0,0x0001},{0x04CF,0x01,0x80,0x000F},{0x04D1,0x5F,0x90,0x0001},

  {0x0561,0x26,0x80,0x0030},{0x0587,0x01,0x02,0x0012},{0x10D0,0x2B,0x40,0x0BC0},{0x10FD,0x03,0x40,0x0BC0},{0x13F8,0x06,0x80,0x0008},{0x1C80,0x01,0x80,0x186E},{0x1C81,0x01,0x80,0x186D},{0x1C82,0x01,0x80,0x1864},

  {0x1C83,0x02,0x80,0x1862},{0x1C85,0x01,0x80,0x1863},{0x1C86,0x01,0x80,0x185C},{0x1C87,0x01,0x80,0x1825},{0x1C88,0x01,0x40,0x89C2},{0x1C8A,0x01,0xA0,0x0001},{0x1D79,0x01,0x40,0x8A04},{0x1D7D,0x01,0x40,0x0EE6},

  {0x1D8E,0x01,0x40,0x8A38},{0x1E01,0x95,0x90,0x0001},{0x1E96,0x01,0x02,0x0028},{0x1E97,0x01,0x02,0x002A},{0x1E98,0x01,0x02,0x002C},{0x1E99,0x01,0x02,0x002E},{0x1E9A,0x01,0x02,0x0030},{0x1E9B,0x01,0x80,0x003B},

  {0x1EA1,0x5F,0x90,0x0001},{0x1F00,0x08,0x40,0x0008},{0x1F10,0x06,0x40,0x0008},{0x1F20,0x08,0x40,0x0008},{0x1F30,0x08,0x40,0x0008},{0x1F40,0x06,0x40,0x0008},{0x1F50,0x01,0x02,0x0032},{0x1F51,0x01,0x40,0x0008},

  {0x1F52,0x01,0x03,0x0034},{0x1F53,0x01,0x40,0x0008},{0x1F54,0x01,0x03,0x0037},{0x1F55,0x01,0x40,0x0008},{0x1F56,0x01,0x03,0x003A},{0x1F57,0x01,0x40,0x0008},{0x1F60,0x08,0x40,0x0008},{0x1F70,0x02,0x40,0x004A},

  {0x1F72,0x04,0x40,0x0056},{0x1F76,0x02,0x40,0x0064},{0x1F78,0x02,0x40,0x0080},{0x1F7A,0x02,0x40,0x0070},{0x1F7C,0x02,0x40,0x007E},{0x1F80,0x01,0x02,0x005B},{0x1F81,0x01,0x02,0x005D},{0x1F82,0x01,0x02,0x005F},

  {0x1F83,0x01,0x02,0x0061},{0x1F84,0x01,0x02,0x0063},{0x1F85,0x01,0x02,0x0065},{0x1F86,0x01,0x02,0x0067},{0x1F87,0x01,0x02,0x0069},{0x1F88,0x01,0x02,0x006B},{0x1F89,0x01,0x02,0x006D},{0x1F8A,0x01,0x02,0x006F},

  {0x1F8B,0x01,0x02,0x0071},{0x1F8C,0x01,0x02,0x0073},{0x1F8D,0x01,0x02,0x0075},{0x1F8E,0x01,0x02,0x0077},{0x1F8F,0x01,0x02,0x0079},{0x1F90,0x01,0x02,0x007B},{0x1F91,0x01,0x02,0x007D},{0x1F92,0x01,0x02,0x007F},

  {0x1F93,0x01,0x02,0x0081},{0x1F94,0x01,0x02,0x0083},{0x1F95,0x01,0x02,0x0085},{0x1F96,0x01,0x02,0x0087},{0x1F97,0x01,0x02,0x0089},{0x1F98,0x01,0x02,0x008B},{0x1F99,0x01,0x02,0x008D},{0x1F9A,0x01,0x02,0x008F},

  {0x1F9B,0x01,0x02,0x0091},{0x1F9C,0x01,0x02,0x0093},{0x1F9D,0x01,0x02,0x0095},{0x1F9E,0x01,0x02,0x0097},{0x1F9F,0x01,0x02,0x0099},{0x1FA0,0x01,0x02,0x009B},{0x1FA1,0x01,0x02,0x009D},{0x1FA2,0x01,0x02,0x009F},

  {0x1FA3,0x01,0x02,0x00A1},{0x1FA4,0x01,0x02,0x00A3},{0x1FA5,0x01,0x02,0x00A5},{0x1FA6,0x01,0x02,0x00A7},{0x1FA7,0x01,0x02,0x00A9},{0x1FA8,0x01,0x02,0x00AB},{0x1FA9,0x01,0x02,0x00AD},{0x1FAA,0x01,0x02,0x00AF},

  {0x1FAB,0x01,0x02,0x00B1},{0x1FAC,0x01,0x02,0x00B3},{0x1FAD,0x01,0x02,0x00B5},{0x1FAE,0x01,0x02,0x00B7},{0x1FAF,0x01,0x02,0x00B9},{0x1FB0,0x02,0x40,0x0008},{0x1FB2,0x01,0x02,0x00C7},{0x1FB3,0x01,0x02,0x00BB},

  {0x1FB4,0x01,0x02,0x00C9},{0x1FB6,0x01,0x02,0x003D},{0x1FB7,0x01,0x03,0x00D3},{0x1FBC,0x01,0x02,0x00BD},{0x1FBE,0x01,0x80,0x1C25},{0x1FC2,0x01,0x02,0x00CB},{0x1FC3,0x01,0x02,0x00BF},{0x1FC4,0x01,0x02,0x00CD},

  {0x1FC6,0x01,0x02,0x003F},{0x1FC7,0x01,0x03,0x00D6},{0x1FCC,0x01,0x02,0x00C1},{0x1FD0,0x02,0x40,0x0008},{0x1FD2,0x01,0x03,0x0041},{0x1FD3,0x01,0x03,0x0044},{0x1FD6,0x01,0x02,0x0047},{0x1FD7,0x01,0x03,0x0049},

  {0x1FE0,0x02,0x40,0x0008},{0x1FE2,0x01,0x03,0x004C},{0x1FE3,0x01,0x03,0x004F},{0x1FE4,0x01,0x02,0x0052},{0x1FE5,0x01,0x40,0x0007},{0x1FE6,0x01,0x02,0x0054},{0x1FE7,0x01,0x03,0x0056},{0x1FF2,0x01,0x02,0x00CF},

  {0x1FF3,0x01,0x02,0x00C3},{0x1FF4,0x01,0x02,0x00D1},{0x1FF6,0x01,0x02,0x0059},{0x1FF7,0x01,0x03,0x00D9},{0x1FFC,0x01,0x02,0x00C5},{0x214E,0x01,0x80,0x001C},{0x2170,0x10,0x80,0x0010},{0x2184,0x01,0xA0,0x0001},

  {0x24D0,0x1A,0x80,0x001A},{0x2C30,0x30,0x80,0x0030},{0x2C61,0x01,0x90,0x0001},{0x2C65,0x01,0x80,0x2A2B},{0x2C66,0x01,0x80,0x2A28},{0x2C68,0x05,0xA0,0x0001},{0x2C73,0x01,0x90,0x0001},{0x2C76,0x01,0xA0,0x0001},

  {0x2C81,0x63,0x90,0x0001},{0x2CEC,0x03,0xA0,0x0001},{0x2CF3,0x01,0x90,0x0001},{0x2D00,0x26,0x80,0x1C60},{0x2D27,0x01,0x80,0x1C60},{0x2D2D,0x01,0x80,0x1C60},{0xA641,0x2D,0x90,0x0001},{0xA681,0x1B,0x90,0x0001},

  {0xA723,0x0D,0x90,0x0001},{0xA733,0x3D,0x90,0x0001},{0xA77A,0x03,0xA0,0x0001},{0xA77F,0x09,0x90,0x0001},{0xA78C,0x01,0xA0,0x0001},{0xA791,0x03,0x90,0x0001},{0xA794,0x01,0x40,0x0030},{0xA797,0x13,0x90,0x0001},

  {0xA7B5,0x0F,0x90,0x0001},{0xA7C8,0x03,0xA0,0x0001},{0xA7CD,0x0F,0x90,0x0001},{0xA7F6,0x01,0xA0,0x0001},{0xAB53,0x01,0x80,0x03A0},{0xAB70,0x50,0x80,0x97D0},{0xFB00,0x01,0x02,0x0002},{0xFB01,0x01,0x02,0x0004},

  {0xFB02,0x01,0x02,0x0006},{0xFB03,0x01,0x03,0x0008},{0xFB04,0x01,0x03,0x000B},{0xFB05,0x01,0x02,0x000E},{0xFB06,0x01,0x02,0x0010},{0xFB13,0x01,0x02,0x0014},{0xFB14,0x01,0x02,0x0016},{0xFB15,0x01,0x02,0x0018},

  {0xFB16,0x01,0x02,0x001A},{0xFB17,0x01,0x02,0x001C},{0xFF41,0x1A,0x80,0x0020},

};

#define mxCharCaseToUpper1Count 12

const txCharCase gxCharCaseToUpper1[mxCharCaseToUpper1Count] ICACHE_XS6RO_ATTR = {

  {0x0428,0x28,0x80,0x0028},{0x04D8,0x24,0x80,0x0028},{0x0597,0x0B,0x80,0x0027},{0x05A3,0x0F,0x80,0x0027},{0x05B3,0x07,0x80,0x0027},{0x05BB,0x02,0x80,0x0027},{0x0CC0,0x33,0x80,0x0040},{0x0D70,0x16,0x80,0x0020},

  {0x18C0,0x20,0x80,0x0020},{0x6E60,0x20,0x80,0x0020},{0x6EBB,0x19,0x80,0x001B},{0xE922,0x22,0x80,0x0022},

};

// COMPILE

typedef struct sxPatternParser txPatternParser;

typedef struct sxCaptureName txCaptureName;

struct sxCaptureName {

  txCaptureName* nextCaptureName;

  txInteger index;

  char string[1];

};

typedef void (*txTermMeasure)(txPatternParser*, void*, txInteger);

typedef void (*txTermCode)(txPatternParser*, void*, txInteger, txInteger);

#define txTermPart\

  void* next;\

  union {\

    txTermMeasure measure;\

    txTermCode code;\

  } dispatch;\

  txInteger step

typedef struct {

  txTermPart;

} txTerm;

typedef struct {

  txTermPart;

  txTerm* term;

  txBoolean not;

  txInteger direction;

  txInteger assertionIndex;

  txInteger completion;

} txAssertion;

typedef struct sxCapture txCapture;

struct sxCapture {

  txTermPart;

  txTerm* term;

  txInteger captureIndex;

  txInteger completion;

  txCaptureName* name;

  txCapture* nextNamedCapture;

};

typedef struct {

  txTermPart;

  txInteger captureIndex;

  txInteger nameIndex;

  char name[1];

} txCaptureReference;

typedef struct {

  txTermPart;

  txInteger stringCount;

  txString* strings;

  txInteger characters[1];

} txCharSet;

enum {

  mxCharSetUnionOp = 0,

  mxCharSetSubtractOp = 1,

  mxCharSetIntersectionOp = 3,

  mxCharSetRangeOp = 4,

};

#define mxCharSetStrings(CHARSET) \

  ((txString)CHARSET + sizeof(txCharSet) + (CHARSET->characters[0] * sizeof(txInteger)))

typedef struct {

  txTermPart;

  txTerm* left;

  txTerm* right;

} txDisjunction;

typedef struct {

  txTermPart;

  txUnsigned add;

  txUnsigned remove;

  txTerm* disjunction;

  txInteger sequel;

} txModifiers;

typedef struct {

  txTermPart;

  txTerm* term;

  txInteger min;

  txInteger max;

  txBoolean greedy;

  txInteger captureIndex;

  txInteger captureCount;

  txInteger quantifierIndex;

  txInteger loop;

  txInteger completion;

} txQuantifier;

typedef struct {

  txTermPart;

  txTerm* left;

  txTerm* right;

} txSequence;

enum {

  XS_REGEXP_NAME = 1 << 9,

};

struct sxPatternParser {

  txMachine* the;

  txTerm* first;

  txUnsigned flags;

  txString pattern;

  txInteger offset;

  txInteger character;

  txInteger surrogate;

  txInteger assertionIndex;

  txInteger captureIndex;

  txInteger nameIndex;

  txInteger quantifierIndex;

  txCaptureName* firstCaptureName;

  txCapture* firstNamedCapture;

  txCapture* lastNamedCapture;

  txInteger size;

  txInteger** code;

  txByte* buffer;

  char* stackLimit;

  c_jmp_buf jmp_buf;

  char error[256];

};

static void* fxCharSetAny(txPatternParser* parser);

static void* fxCharSetCombine(txPatternParser* parser, txCharSet* set1, txCharSet* set2, txInteger op);

static void* fxCharSetDigits(txPatternParser* parser);

static void* fxCharSetEmpty(txPatternParser* parser);

static void* fxCharSetExpression(txPatternParser* parser);

static void* fxCharSetNot(txPatternParser* parser, txCharSet* set);

static void* fxCharSetOperand(txPatternParser* parser, txInteger* kind);

static void* fxCharSetParseEscape(txPatternParser* parser, txBoolean punctuator, txInteger* kind);

static void* fxCharSetParseItem(txPatternParser* parser);

static void* fxCharSetParseList(txPatternParser* parser);

static void* fxCharSetRange(txPatternParser* parser, txCharSet* set1, txCharSet* set2);

static void* fxCharSetSingle(txPatternParser* parser, txInteger character);

static void* fxCharSetSpaces(txPatternParser* parser);

static void* fxCharSetStrings(txPatternParser* parser);

static void* fxCharSetStringsDisjunction(txPatternParser* parser, txCharSet* set);

static void* fxCharSetStringsSequence(txPatternParser* parser, txString string);

static void* fxCharSetUnicodeProperty(txPatternParser* parser);

static void* fxCharSetWords(txPatternParser* parser);

static void fxCaptureNameEscape(txPatternParser* parser);

static txCaptureName* fxCaptureNameGet(txPatternParser* parser, txString string);

static void fxCaptureNameParse(txPatternParser* parser, txInteger* length);

static void fxCaptureNameParticipate(txPatternParser* parser, txCapture* capture);

static txCaptureName* fxCaptureNamePut(txPatternParser* parser, txString string);

static void* fxDisjunctionParse(txPatternParser* parser, txInteger character);

static void* fxModifiersParse(txPatternParser* parser);

static void* fxQuantifierParse(txPatternParser* parser, void* term, txInteger captureIndex);

static txBoolean fxQuantifierParseBrace(txPatternParser* parser, txInteger* min, txInteger* max);

static txBoolean fxQuantifierParseDigits(txPatternParser* parser, txInteger* result);

static void* fxSequenceParse(txPatternParser* parser, txInteger character);

static void fxAssertionMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxCaptureMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxCaptureReferenceMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxCharSetMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxDisjunctionMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxEmptyMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxLineBeginMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxLineEndMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxModifiersMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxQuantifierMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxSequenceMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxWordBreakMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxWordContinueMeasure(txPatternParser* parser, void* it, txInteger direction);

static void fxAssertionCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxCaptureCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxCaptureReferenceCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxCharSetCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxDisjunctionCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxEmptyCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxLineBeginCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxLineEndCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxModifiersCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxQuantifierCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxSequenceCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxWordBreakCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxWordContinueCode(txPatternParser* parser, void* it, txInteger direction, txInteger sequel);

static void fxPatternParserCheckStack(txPatternParser* parser);

static void* fxPatternParserCreateChunk(txPatternParser* parser, txSize size);

static void* fxPatternParserCreateTerm(txPatternParser* parser, size_t size, txTermMeasure measure);

static void fxPatternParserInitialize(txPatternParser* parser);

static txBoolean fxPatternParserDecimal(txPatternParser* parser, txU4* value);

static void fxPatternParserError(txPatternParser* parser, txString format, ...);

static void fxPatternParserEscape(txPatternParser* parser, txBoolean punctuator);

static void fxPatternParserNext(txPatternParser* parser);

static void fxPatternParserTerminate(txPatternParser* parser);

#define mxCodeSize sizeof(txInteger)

#define mxStepSize sizeof(txInteger)

#define mxIndexSize sizeof(txInteger)

#define mxTermStepSize mxCodeSize + mxStepSize

#define mxAssertionNotStepSize mxTermStepSize + mxIndexSize + mxStepSize

#define mxAssertionNotCompletionSize mxCodeSize + mxIndexSize

#define mxAssertionStepSize mxTermStepSize + mxIndexSize

#define mxAssertionCompletionSize mxTermStepSize + mxIndexSize

#define mxCaptureStepSize mxTermStepSize + mxIndexSize

#define mxCaptureCompletionSize mxTermStepSize + mxIndexSize + mxIndexSize

#define mxCaptureReferenceStepSize mxTermStepSize + mxIndexSize + mxIndexSize

#define mxDisjunctionStepSize mxTermStepSize + mxStepSize

#define mxModifiersStepSize mxTermStepSize + sizeof(txInteger)

#define mxQuantifierStepSize mxTermStepSize + mxIndexSize + (2 * sizeof(txInteger))

#define mxQuantifierLoopSize mxTermStepSize + mxIndexSize + mxStepSize + mxIndexSize + mxIndexSize

#define mxQuantifierCompletionSize mxTermStepSize + mxIndexSize + mxStepSize + mxIndexSize + mxIndexSize

enum {

  mxDuplicateCapture,

  mxInvalidCharacter,

  mxInvalidEscape,

  mxInvalidFlags,

  mxInvalidGroup,

  mxInvalidModifiers,

  mxInvalidName,

  mxInvalidPattern,

  mxInvalidQuantifier,

  mxInvalidRange,

  mxInvalidReferenceName,

  mxInvalidReferenceNumber,

  mxInvalidSequence,

  mxInvalidUTF8,

  mxNameOverflow,

  mxNotEnoughMemory,

  mxNativeStackOverflow,

  mxUnicodePropertyEscapeNotBuiltIn,

  mxErrorCount

};

static const txString gxErrors[mxErrorCount] ICACHE_XS6RO_ATTR = {

  "duplicate capture",

  "invalid character",

  "invalid escape",

  "invalid flags",

  "invalid group",

  "invalid modifiers",

  "invalid name",

  "invalid pattern",

  "invalid quantifier",

  "invalid range",

  "invalid reference name \\k<%s>",

  "invalid reference number \\%d",

  "invalid sequence",

  "invalid UTF-8",

  "name overflow",

  "not enough memory",

  "native stack oveflow",

  "unicode property escape not built-in",

};

// MATCH

typedef struct sxStateData txStateData;

typedef struct {

  txInteger offset;

  txStateData* firstState;

} txAssertionData;

typedef struct {

  txInteger from;

  txInteger to;

} txCaptureData;

typedef struct {

  txInteger min;

  txInteger max;

  txInteger offset;

} txQuantifierData;

struct sxStateData {

  txMachine* the;

  txStateData* nextState;

  txInteger step;

  txInteger offset;

  txUnsigned flags;

  txCaptureData captures[1];

};

static txInteger fxFindCharacter(txString input, txInteger offset, txInteger direction, txInteger flags);

static txInteger fxGetCharacter(txString input, txInteger offset, txInteger flags);

static txBoolean fxMatchCharacter(txInteger* characters, txInteger character);

static txStateData* fxPopStates(txMachine* the, txStateData* fromState, txStateData* toState);

static txStateData* fxPushState(txMachine* the, txStateData* firstState, txInteger step, txInteger offset, txUnsigned flags, txCaptureData* captures, txInteger captureCount);

#ifdef mxTrace

  static txString gxStepNames[cxModifiersStep + 1] = {

    "MatchStep",

    "AssertionStep",

    "AssertionCompletion",

    "AssertionNotStep",

    "AssertionNotCompletion",

    "CaptureForwardStep",

    "CaptureForwardCompletion",

    "CaptureBackwardStep",

    "CaptureBackwardCompletion",

    "CaptureReferenceForwardStep",

    "CaptureReferenceBackwardStep",

    "CharSetForwardStep",

    "CharSetBackwardStep",

    "DisjunctionStep",

    "EmptyStep",

    "LineBeginStep",

    "LineEndStep",

    "QuantifierStep",

    "QuantifierGreedyLoop",

    "QuantifierLazyLoop",

    "QuantifierCompletion",

    "WordBreakStep",

    "WordContinueStep",

    "ModifiersStep"

  };

#endif

static const txInteger gxLineCharacters[7] ICACHE_XS6RO_ATTR = { 6, 0x000A, 0x000A + 1, 0x000D, 0x000D + 1, 0x2028, 0x2029 + 1 };

static const txInteger gxWordCharacters[9] ICACHE_XS6RO_ATTR = { 8, '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1 };

// COMMON

txInteger fxCharCaseCanonicalize(txInteger character, txBoolean flag)

{

  txCharCase charCase;

  txCharCase* it;

  if (character < 0x80) {

    if (flag)

      it = (txCharCase*)gxCharCaseFold0;

    else

      it = (txCharCase*)gxCharCaseIgnore0;

    if (character < it->code)

      it = C_NULL;

    else if ((it->code + it->count) <= character)

      it = C_NULL;

  }

  else if (character < 0x10000) {

    charCase.code = (txU2)character;

    charCase.count = 1;

    if (flag)

      it = (txCharCase*)c_bsearch(&charCase, gxCharCaseFold0, mxCharCaseFold0Count, sizeof(txCharCase), fxCharCaseCompare);

    else

      it = (txCharCase*)c_bsearch(&charCase, gxCharCaseIgnore0, mxCharCaseIgnore0Count, sizeof(txCharCase), fxCharCaseCompare);

  }

  else {

    charCase.code = (txU2)(character & 0xFFFF);

    charCase.count = 1;

    if (flag)

      it = (txCharCase*)c_bsearch(&charCase, gxCharCaseFold1, mxCharCaseFold1Count, sizeof(txCharCase), fxCharCaseCompare);

    else

      it = C_NULL;

  }

  if (it) {

    txU1 operand = it->operand;

    if ((operand & 0x10) && ((character & 1) == 0))

      return character;

    if ((operand & 0x20) && (character & 1))

      return character;

    if (operand & 0x40)

      character += it->delta;

    else if (operand & 0x80)

      character -= it->delta;

  }

  return character;

}

int fxCharCaseCompare(const void *p1, const void *p2)

{

  txCharCase* c1 = (txCharCase*)p1;

  txCharCase* c2 = (txCharCase*)p2;

  if (c1->code + c1->count <= c2->code)

    return -1;

  if (c1->code >= c2->code + c2->count)

    return 1;

  return 0;

}

// COMPILE

void* fxCharSetAny(txPatternParser* parser)

{

  txCharSet* result;

  if (parser->flags & XS_REGEXP_S) {

    result = fxPatternParserCreateTerm(parser, sizeof(txCharSet) + (2 * sizeof(txInteger)), fxCharSetMeasure);

    result->stringCount = 0;

    result->strings = C_NULL;

    result->characters[0] = 2;

    result->characters[1] = 0x0000;

    result->characters[2] = 0x7FFFFFFF;

  }

  else {

    result = fxPatternParserCreateTerm(parser, sizeof(txCharSet) + (8 * sizeof(txInteger)), fxCharSetMeasure);

    result->stringCount = 0;

    result->strings = C_NULL;

    result->characters[0] = 8;

    result->characters[1] = 0x0000;

    result->characters[2] = 0x000A;

    result->characters[3] = 0x000B;

    result->characters[4] = 0x000D;

    result->characters[5] = 0x000E;

    result->characters[6] = 0x2028;

    result->characters[7] = 0x2030;

    result->characters[8] = 0x7FFFFFFF;

  }

  return result;

}

void* fxCharSetCanonicalizeSingle(txPatternParser* parser, txCharSet* set)

{

  if ((parser->flags & XS_REGEXP_I) && (set->characters[0] == 2) && (set->characters[1] + 1 == set->characters[2])) {

    txBoolean flag = (parser->flags & XS_REGEXP_UV) ? 1 : 0;

    set->characters[1] = fxCharCaseCanonicalize(set->characters[1], flag);

    set->characters[2] = set->characters[1] + 1;

  }

  return set;

}

void* fxCharSetCombine(txPatternParser* parser, txCharSet* set1, txCharSet* set2, txInteger op)

{

  txInteger flag = 0;

  txInteger old = 0;

  txInteger* current1 = set1->characters + 1;

  txInteger* limit1 = current1 + set1->characters[0];

  txInteger* current2 = set2->characters + 1;

  txInteger* limit2 = current2 + set2->characters[0];

  txCharSet* result = fxPatternParserCreateTerm(parser, sizeof(txCharSet) + ((set1->characters[0] + set2->characters[0]) * sizeof(txInteger)), fxCharSetMeasure);

  txInteger count0 = 0;

  txInteger* current0 = result->characters + 1;

  while ((current1 < limit1) && (current2 < limit2)) {

    txInteger test = *current1 - *current2;

    txInteger character;

    if (test <= 0) {

      character = *current1;

      flag ^= 1;

      current1++;

    }

    if (test >= 0) {

      character = *current2;

      flag ^= 2;

      current2++;

    }

    if ((flag == op) || (old == op)) {

      count0++;

      *current0++ = character;

    }

    old = flag;

  }

  if ((op & 2) == 0) {

    while (current1 < limit1) {

      count0++;

      *current0++ = *current1++;

    }

  }

  if ((op & 1) == 0) {

    while (current2 < limit2) {

      count0++;

      *current0++ = *current2++;

    }

  }

  result->stringCount = 0;

  result->strings = C_NULL;

  result->characters[0] = count0;

  if (set1->strings && set2->strings) {

    txInteger count1 = set1->stringCount;

    txInteger count2 = set2->stringCount;

    txInteger index1 = 0;

    txInteger index2 = 0;

    txInteger count = 0;

    txString string1 = set1->strings[index1];

    txString string2 = set2->strings[index2];

    txInteger length1 = fxUnicodeLength(string1, C_NULL);

    txInteger length2 = fxUnicodeLength(string2, C_NULL);

    if (op == mxCharSetUnionOp)

      count = count1 + count2;

    else if (op == mxCharSetSubtractOp)

      count = count1;

    else

      count = (count1 < count2) ? count1 : count2;

    result->strings = fxPatternParserCreateChunk(parser, count * sizeof(txString));

    count = 0;

    while ((index1 < count1) && (index2 < count2)) {

      txInteger copy = 0;

      txInteger advance = 0;

      if (length1 > length2) {

        if (op != mxCharSetIntersectionOp)

          copy = 1;

        advance = 1;

      }

      else if (length1 < length2) {

        if (op == mxCharSetUnionOp)

          copy = 2;

        advance = 2;

      }

      else {

        txInteger delta = c_strcmp(string1, string2);

        if (delta > 0) {

          if (op != mxCharSetIntersectionOp)

            copy = 1;

          advance = 1;

        }

        else if (delta < 0) {

          if (op == mxCharSetUnionOp)

            copy = 2;

          advance = 2;

        }

        else {

          if (op != mxCharSetSubtractOp)

            copy = 1;

          advance = 3;

        }

      }

      if (copy == 1) {

        result->strings[count] = string1;

        count++;

      }

      else if (copy == 2) {

        result->strings[count] = string2;

        count++;

      }

      if (advance & 1) {

        index1++;

        if (index1 < count1) {

          string1 = set1->strings[index1];

          length1 = fxUnicodeLength(string1, C_NULL);

        }

      }

      if (advance & 2) {

        index2++;

        if (index2 < count2) {

          string2 = set2->strings[index2];

          length2 = fxUnicodeLength(string2, C_NULL);

        }

      }

    }

    if (index1 < count1) {

      if (op != mxCharSetIntersectionOp) {

        while (index1 < count1) {

          result->strings[count] = set1->strings[index1];

          count++;

          index1++;

        }

      }

    }

    else if (index2 < count2) {

      if (op == mxCharSetUnionOp) {

        while (index2 < count2) {

          result->strings[count] = set2->strings[index2];

          count++;

          index2++;

        }

      }

    }

    if (count)

      result->stringCount = count;

    else

      result->strings = C_NULL;

  }

  else if (set1->strings) {

    if (op != mxCharSetIntersectionOp) {

      result->stringCount = set1->stringCount;

      result->strings = set1->strings;

    }

  }

  else if (set2->strings) {

    if (op == mxCharSetUnionOp) {

      result->stringCount = set2->stringCount;

      result->strings = set2->strings;

    }

  }

  return result;

}

void* fxCharSetDigits(txPatternParser* parser)

{

  txCharSet* result = fxPatternParserCreateTerm(parser, sizeof(txCharSet) + (2 * sizeof(txInteger)), fxCharSetMeasure);

  result->stringCount = 0;

  result->strings = C_NULL;

  result->characters[0] = 2;

  result->characters[1] = '0';

  result->characters[2] = '9' + 1;

  return result;

}

void* fxCharSetEmpty(txPatternParser* parser)

{

  txCharSet* result = fxPatternParserCreateTerm(parser, sizeof(txCharSet), fxCharSetMeasure);

  result->stringCount = 0;

  result->strings = C_NULL;

  result->characters[0] = 0;

  return result;

}

void* fxCharSetExpression(txPatternParser* parser)

{

  txBoolean not = 0;

  void* result = NULL;

  void* left = NULL;

  txInteger leftKind = 0;

  void* right = NULL;

  txInteger rightKind = 0;

  txString string;

  fxPatternParserCheckStack(parser);

  if (parser->character == '^') {

    fxPatternParserNext(parser);

    not = 1;

  }

  left = fxCharSetOperand(parser, &leftKind);

  string = parser->pattern + parser->offset;

  if ((parser->character == '-') && (*string == '-')) {

    for (;;) {

      fxPatternParserNext(parser);

      fxPatternParserNext(parser);

      right = fxCharSetOperand(parser, &rightKind); 

      result = fxCharSetCombine(parser, left, right, mxCharSetSubtractOp);

      if (parser->character == ']')

        break;    

      string = parser->pattern + parser->offset;

      if ((parser->character == '-') && (*string == '-')) {

        left = result;

        continue;

      }

      fxPatternParserError(parser, gxErrors[mxInvalidRange]);

    }

  }

  else if ((parser->character == '&') && (*string == '&')) {

    for (;;) {

      fxPatternParserNext(parser);

      fxPatternParserNext(parser);

      right = fxCharSetOperand(parser, &rightKind); 

      result = fxCharSetCombine(parser, left, right, mxCharSetIntersectionOp);

      if (parser->character == ']')

        break;    

      string = parser->pattern + parser->offset;

      if ((parser->character == '&') && (*string == '&')) {

        left = result;

        continue;

      }

      fxPatternParserError(parser, gxErrors[mxInvalidRange]);

    }

  }

  else {

    for (;;) {

      if (parser->character == '-') {

        fxPatternParserNext(parser);

        right = fxCharSetOperand(parser, &rightKind);

        if ((leftKind != 0) && (rightKind != 0))

          fxPatternParserError(parser, gxErrors[mxInvalidRange]);

        left = fxCharSetRange(parser, left, right);

      }

      if (result)

        result = fxCharSetCombine(parser, result, left, mxCharSetUnionOp);

      else

        result = left;

      if (parser->character == ']')

        break;    

      left = fxCharSetOperand(parser, &leftKind);

    }

  }

  if (not && result)

    result = fxCharSetNot(parser, result);

  return result;

}

void* fxCharSetNot(txPatternParser* parser, txCharSet* set)

{

  if (set->strings == C_NULL) {

    txCharSet* result = fxPatternParserCreateTerm(parser, sizeof(txCharSet) + ((set->characters[0] + 2) * sizeof(txInteger)), fxCharSetMeasure);

    txInteger* current1 = set->characters + 1;

    txInteger* limit1 = current1 + set->characters[0];

    txInteger count0 = 0;

    txInteger* current0 = result->characters + 1;

    txInteger character = 0;

    while (current1 < limit1) {

      txInteger begin = *current1++;

      txInteger end = *current1++;

      if (character < begin) {

        count0++;

        *current0++ = character;

        count0++;

        *current0++ = begin;

      }

      character = end;

    }

    if (character < 0x7FFFFFFF) {

      count0++;

      *current0++ = character;

      count0++;

      *current0++ = 0x7FFFFFFF;

    }

    result->stringCount = 0;

    result->strings = C_NULL;

    result->characters[0] = count0;

    return result;

  }

  fxPatternParserError(parser, gxErrors[mxInvalidPattern]);

  return C_NULL;

}

void* fxCharSetOperand(txPatternParser* parser, txInteger* kind)

{

  void* result = NULL;

  if (parser->character == C_EOF) {

    fxPatternParserError(parser, gxErrors[mxInvalidRange]);

  }

  else if (parser->character == '[') {

    fxPatternParserNext(parser);

    result = fxCharSetExpression(parser); 

    *kind = 1;

    if (parser->character != ']')

      fxPatternParserError(parser, gxErrors[mxInvalidRange]);

    fxPatternParserNext(parser);

  }

  else if (parser->character == '\\') {

    fxPatternParserNext(parser);

    if (parser->character == 'q') {

      result = fxCharSetStrings(parser);

      *kind = 1;

    }

    else

      result = fxCharSetParseEscape(parser, 1, kind);

  }

  else if (c_strchr("&!#$%*+,.:;<=>?@^`~", parser->character)) {

    txInteger character = parser->character;

    fxPatternParserNext(parser);

    if (character == parser->character)

      fxPatternParserError(parser, gxErrors[mxInvalidRange]);

    result = fxCharSetSingle(parser, character);

    *kind = 0;

  }

  else if (c_strchr("()[]{}/-\\|", parser->character)) {

    fxPatternParserError(parser, gxErrors[mxInvalidRange]);

  }

  else {

    result = fxCharSetSingle(parser, parser->character);

    fxPatternParserNext(parser);

    *kind = 0;

  }

  return result;

}

void* fxCharSetParseEscape(txPatternParser* parser, txBoolean punctuator, txInteger* kind)

{

  void* result = NULL;

  txInteger flag = 1;

  switch(parser->character) {

  case C_EOF:

    break;

  // character classes

  case 'd': 

    result = fxCharSetDigits(parser); 

    fxPatternParserNext(parser);

    break;

  case 'D':

    result = fxCharSetNot(parser, fxCharSetDigits(parser));

    fxPatternParserNext(parser);

    break;

  case 's':

    result = fxCharSetSpaces(parser);

    fxPatternParserNext(parser);

    break;

  case 'S':

    result = fxCharSetNot(parser, fxCharSetSpaces(parser));

    fxPatternParserNext(parser);

    break;

  case 'w':

    result = fxCharSetWords(parser);

    fxPatternParserNext(parser);

    break;

  case 'W':

    result = fxCharSetNot(parser, fxCharSetWords(parser));

    fxPatternParserNext(parser);

    break;

  case 'p':

    result = fxCharSetUnicodeProperty(parser);

    fxPatternParserNext(parser);

    break;

  case 'P':

    result = fxCharSetNot(parser, fxCharSetUnicodeProperty(parser));

    fxPatternParserNext(parser);

    break;

  default:

    fxPatternParserEscape(parser, punctuator);

    result = fxCharSetSingle(parser, parser->character);

    fxPatternParserNext(parser);

    flag = 0;

    break;

  }

  if (result == NULL)

    fxPatternParserError(parser, gxErrors[mxInvalidEscape]);

  if (kind)

    *kind = flag;

  return result;

}

void* fxCharSetParseItem(txPatternParser* parser)

{

  void* result = NULL;

  if (parser->character == '-') {

    result = fxCharSetSingle(parser, '-');

    fxPatternParserNext(parser);

  }

  else if (parser->character == '\\') {

    fxPatternParserNext(parser);

    if (parser->character == 'b') {

      fxPatternParserNext(parser);

      result = fxCharSetSingle(parser, 8);

    }

    else if (parser->character == '-') {

      fxPatternParserNext(parser);

      result = fxCharSetSingle(parser, '-');

    }

    else

      result = fxCharSetParseEscape(parser, 0, C_NULL);

  }

  else if (parser->character == ']') {

    result = fxCharSetEmpty(parser);

  }  

  else {

    result = fxCharSetSingle(parser, parser->character);

    fxPatternParserNext(parser);

  }

  return result;

}

void* fxCharSetParseList(txPatternParser* parser)

{

  txBoolean not = 0;

  void* former = NULL;

  void* result = NULL;

  if (parser->character == '^') {

    fxPatternParserNext(parser);