From: "Leif Lindholm" <leif.lindholm@linaro.org>
To: "Gao, Liming" <liming.gao@intel.com>
Cc: "devel@edk2.groups.io" <devel@edk2.groups.io>,
"Feng, Bob C" <bob.c.feng@intel.com>
Subject: Re: [PATCH 3/7] BaseTools: strip trailing whitespace
Date: Fri, 20 Sep 2019 11:37:08 +0100 [thread overview]
Message-ID: <20190920103708.GE28454@bivouac.eciton.net> (raw)
In-Reply-To: <4A89E2EF3DFEDB4C8BFDE51014F606A14E4FF320@SHSMSX104.ccr.corp.intel.com>
Hi Liming,
I think that is fine for LzmaCompress and BrotliCompress, but I also
think that is a strong indicator we should then be converting them to
submodules. This would be beneficial also from a licensing standpoint.
For Pccts and LzmaCompress there aren't really upstreams (although
Jordan has set up a repo on github). So we may need to make our own.
I can remove the modifications in these modules for now and send out a
v2 of 3/7 only.
Regards,
Leif
On Fri, Sep 20, 2019 at 06:06:41AM +0000, Gao, Liming wrote:
> Leif:
> Pccts, LzmaCompress/Sdk and BrotliCompress/tools are from third party code.
> I would like to keep the code similar to their origin one with the minimal changes.
> If so, the sync will be easy. Can we add the exception to skip them?
>
> Thanks
> Liming
> > -----Original Message-----
> > From: Leif Lindholm [mailto:leif.lindholm@linaro.org]
> > Sent: Friday, September 20, 2019 2:06 AM
> > To: devel@edk2.groups.io
> > Cc: Feng, Bob C <bob.c.feng@intel.com>; Gao, Liming <liming.gao@intel.com>
> > Subject: [PATCH 3/7] BaseTools: strip trailing whitespace
> >
> > Cc: Bob Feng <bob.c.feng@intel.com>
> > Cc: Liming Gao <liming.gao@intel.com>
> > Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
> > ---
> > BaseTools/Source/C/BrotliCompress/tools/brotli.c | 2 +-
> > BaseTools/Source/C/GNUmakefile | 2 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c | 20 ++---
> > BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h | 4 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c | 22 ++---
> > BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h | 8 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c | 70 ++++++++--------
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h | 4 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c | 40 +++++-----
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h | 4 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c | 30 +++----
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h | 4 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c | 194 ++++++++++++++++++++++----------------------
> > BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c | 6 +-
> > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt | 92 ++++++++++-----------
> > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt | 102 ++++++++++++------------
> > BaseTools/Source/C/Makefiles/app.makefile | 4 +-
> > BaseTools/Source/C/Makefiles/footer.makefile | 4 +-
> > BaseTools/Source/C/Makefiles/header.makefile | 8 +-
> > BaseTools/Source/C/Makefiles/lib.makefile | 2 +-
> > BaseTools/Source/C/Makefiles/ms.common | 4 +-
> > BaseTools/Source/C/VfrCompile/GNUmakefile | 6 +-
> > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt | 286
> > ++++++++++++++++++++++++++++++++---------------------------------
> > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt | 6 +-
> > BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt | 20 ++---
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c | 194 ++++++++++++++++++++++----------------------
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c | 10 +--
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c | 18 ++---
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c | 12 +--
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c | 16 ++--
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c | 16 ++--
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c | 78 +++++++++---------
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c | 10 +--
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c | 6 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c | 40 +++++-----
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c | 42 +++++-----
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c | 4072
> > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------
> > -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
> > -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
> > -------------------------------------------------
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c | 10 +--
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c | 950
> > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------
> > ------------------------------------------------------------------------------------------
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c | 30 +++----
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c | 10 +--
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp | 6 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h | 22 ++---
> > BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp | 2 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp | 8 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h | 10 +--
> > BaseTools/Source/C/VfrCompile/Pccts/h/ast.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/h/err.h | 70 ++++++++--------
> > BaseTools/Source/C/VfrCompile/Pccts/history.txt | 6 +-
> > BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c | 14 ++--
> > BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c | 46 +++++------
> > BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c | 46 +++++------
> > BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h | 4 +-
> > BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c | 26 +++---
> > BaseTools/Source/Python/Ecc/Check.py | 2 +-
> > BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 2 +-
> > BaseTools/Source/Python/Makefile | 2 +-
> > 75 files changed, 3404 insertions(+), 3404 deletions(-)
> >
> > diff --git a/BaseTools/Source/C/BrotliCompress/tools/brotli.c b/BaseTools/Source/C/BrotliCompress/tools/brotli.c
> > index b0246e1ecf86..946da96013da 100644
> > --- a/BaseTools/Source/C/BrotliCompress/tools/brotli.c
> > +++ b/BaseTools/Source/C/BrotliCompress/tools/brotli.c
> > @@ -909,7 +909,7 @@ static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) {
> >
> >
> > /* Default brotli_alloc_func */
> >
> > void* BrotliAllocFunc(void* opaque, size_t size) {
> >
> > - *(size_t *)opaque = *(size_t *) opaque + size;
> >
> > + *(size_t *)opaque = *(size_t *) opaque + size;
> >
> > return malloc(size);
> >
> > }
> >
> >
> >
> > diff --git a/BaseTools/Source/C/GNUmakefile b/BaseTools/Source/C/GNUmakefile
> > index 37bcce519c7e..df4eb64ea95e 100644
> > --- a/BaseTools/Source/C/GNUmakefile
> > +++ b/BaseTools/Source/C/GNUmakefile
> > @@ -77,7 +77,7 @@ $(SUBDIRS):
> > $(patsubst %,%-clean,$(sort $(SUBDIRS))):
> >
> > -$(MAKE) -C $(@:-clean=) clean
> >
> >
> >
> > -$(VFRAUTOGEN): VfrCompile/VfrSyntax.g
> >
> > +$(VFRAUTOGEN): VfrCompile/VfrSyntax.g
> >
> > $(MAKE) -C VfrCompile VfrLexer.h
> >
> >
> >
> > clean: $(patsubst %,%-clean,$(sort $(SUBDIRS)))
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
> > index e486901e3022..76169000d54d 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
> > @@ -122,12 +122,12 @@ WRes File_Read(CSzFile *p, void *data, size_t *size)
> > return 0;
> >
> >
> >
> > #else
> >
> > -
> >
> > +
> >
> > *size = fread(data, 1, originalSize, p->file);
> >
> > if (*size == originalSize)
> >
> > return 0;
> >
> > return ferror(p->file);
> >
> > -
> >
> > +
> >
> > #endif
> >
> > }
> >
> >
> >
> > @@ -136,7 +136,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
> > size_t originalSize = *size;
> >
> > if (originalSize == 0)
> >
> > return 0;
> >
> > -
> >
> > +
> >
> > #ifdef USE_WINDOWS_FILE
> >
> >
> >
> > *size = 0;
> >
> > @@ -162,7 +162,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
> > if (*size == originalSize)
> >
> > return 0;
> >
> > return ferror(p->file);
> >
> > -
> >
> > +
> >
> > #endif
> >
> > }
> >
> >
> >
> > @@ -192,7 +192,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
> > return 0;
> >
> >
> >
> > #else
> >
> > -
> >
> > +
> >
> > int moveMethod;
> >
> > int res;
> >
> > switch (origin)
> >
> > @@ -205,14 +205,14 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
> > res = fseek(p->file, (long)*pos, moveMethod);
> >
> > *pos = ftell(p->file);
> >
> > return res;
> >
> > -
> >
> > +
> >
> > #endif
> >
> > }
> >
> >
> >
> > WRes File_GetLength(CSzFile *p, UInt64 *length)
> >
> > {
> >
> > #ifdef USE_WINDOWS_FILE
> >
> > -
> >
> > +
> >
> > DWORD sizeHigh;
> >
> > DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
> >
> > if (sizeLow == 0xFFFFFFFF)
> >
> > @@ -223,15 +223,15 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
> > }
> >
> > *length = (((UInt64)sizeHigh) << 32) + sizeLow;
> >
> > return 0;
> >
> > -
> >
> > +
> >
> > #else
> >
> > -
> >
> > +
> >
> > long pos = ftell(p->file);
> >
> > int res = fseek(p->file, 0, SEEK_END);
> >
> > *length = ftell(p->file);
> >
> > fseek(p->file, pos, SEEK_SET);
> >
> > return res;
> >
> > -
> >
> > +
> >
> > #endif
> >
> > }
> >
> >
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
> > index 4977cdaa66d9..ab7baee4c4fa 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
> > @@ -241,10 +241,10 @@ typedef struct
> > {
> >
> > ILookInStream vt;
> >
> > const ISeekInStream *realStream;
> >
> > -
> >
> > +
> >
> > size_t pos;
> >
> > size_t size; /* it's data size */
> >
> > -
> >
> > +
> >
> > /* the following variables must be set outside */
> >
> > Byte *buf;
> >
> > size_t bufSize;
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
> > index 30b499e5ff7c..dc8f17977cc1 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
> > @@ -108,13 +108,13 @@ static void PrintAddr(void *p)
> > PrintHex(size, 10); \
> >
> > PrintAddr(ptr); \
> >
> > PrintLn();
> >
> > -
> >
> > +
> >
> > #define PRINT_FREE(name, cnt, ptr) if (ptr) { \
> >
> > Print(name " "); \
> >
> > PrintDec(--cnt, 10); \
> >
> > PrintAddr(ptr); \
> >
> > PrintLn(); }
> >
> > -
> >
> > +
> >
> > #else
> >
> >
> >
> > #define PRINT_ALLOC(name, cnt, size, ptr)
> >
> > @@ -147,7 +147,7 @@ void *MyAlloc(size_t size)
> > void MyFree(void *address)
> >
> > {
> >
> > PRINT_FREE("Free ", g_allocCount, address);
> >
> > -
> >
> > +
> >
> > free(address);
> >
> > }
> >
> >
> >
> > @@ -157,9 +157,9 @@ void *MidAlloc(size_t size)
> > {
> >
> > if (size == 0)
> >
> > return NULL;
> >
> > -
> >
> > +
> >
> > PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
> >
> > -
> >
> > +
> >
> > return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
> >
> > }
> >
> >
> >
> > @@ -203,7 +203,7 @@ void *BigAlloc(size_t size)
> > return NULL;
> >
> >
> >
> > PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
> >
> > -
> >
> > +
> >
> > #ifdef _7ZIP_LARGE_PAGES
> >
> > {
> >
> > SIZE_T ps = g_LargePageSize;
> >
> > @@ -228,7 +228,7 @@ void *BigAlloc(size_t size)
> > void BigFree(void *address)
> >
> > {
> >
> > PRINT_FREE("Free-Big", g_allocCountBig, address);
> >
> > -
> >
> > +
> >
> > if (!address)
> >
> > return;
> >
> > VirtualFree(address, 0, MEM_RELEASE);
> >
> > @@ -322,7 +322,7 @@ static int posix_memalign(void **ptr, size_t align, size_t size)
> > static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
> >
> > {
> >
> > #ifndef USE_posix_memalign
> >
> > -
> >
> > +
> >
> > void *p;
> >
> > void *pAligned;
> >
> > size_t newSize;
> >
> > @@ -336,7 +336,7 @@ static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
> > return NULL;
> >
> >
> >
> > p = MyAlloc(newSize);
> >
> > -
> >
> > +
> >
> > if (!p)
> >
> > return NULL;
> >
> > pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
> >
> > @@ -402,7 +402,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
> >
> >
> > if (alignSize < sizeof(void *))
> >
> > alignSize = sizeof(void *);
> >
> > -
> >
> > +
> >
> > if (p->offset >= alignSize)
> >
> > return NULL;
> >
> >
> >
> > @@ -414,7 +414,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
> > return NULL;
> >
> >
> >
> > adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
> >
> > -
> >
> > +
> >
> > if (!adr)
> >
> > return NULL;
> >
> >
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
> > index aba8dce14f19..ecf7b0c44759 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
> > @@ -11,23 +11,23 @@ EXTERN_C_BEGIN
> > /*
> >
> > These functions convert relative addresses to absolute addresses
> >
> > in CALL instructions to increase the compression ratio.
> >
> > -
> >
> > +
> >
> > In:
> >
> > data - data buffer
> >
> > size - size of data
> >
> > ip - current virtual Instruction Pinter (IP) value
> >
> > state - state variable for x86 converter
> >
> > encoding - 0 (for decoding), 1 (for encoding)
> >
> > -
> >
> > +
> >
> > Out:
> >
> > state - state variable for x86 converter
> >
> >
> >
> > Returns:
> >
> > The number of processed bytes. If you call these functions with multiple calls,
> >
> > you must start next call with first byte after block of processed bytes.
> >
> > -
> >
> > +
> >
> > Type Endian Alignment LookAhead
> >
> > -
> >
> > +
> >
> > x86 little 1 4
> >
> > ARMT little 2 2
> >
> > ARM little 4 0
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
> > index 6ea82a9b5344..507eb026f168 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
> > @@ -73,7 +73,7 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
> > p->streamEndWasReached = 1;
> >
> > return;
> >
> > }
> >
> > -
> >
> > +
> >
> > for (;;)
> >
> > {
> >
> > Byte *dest = p->buffer + (p->streamPos - p->pos);
> >
> > @@ -180,24 +180,24 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
> > ISzAllocPtr alloc)
> >
> > {
> >
> > UInt32 sizeReserv;
> >
> > -
> >
> > +
> >
> > if (historySize > kMaxHistorySize)
> >
> > {
> >
> > MatchFinder_Free(p, alloc);
> >
> > return 0;
> >
> > }
> >
> > -
> >
> > +
> >
> > sizeReserv = historySize >> 1;
> >
> > if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3;
> >
> > else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2;
> >
> > -
> >
> > +
> >
> > sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);
> >
> >
> >
> > p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
> >
> > p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
> >
> > -
> >
> > +
> >
> > /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
> >
> > -
> >
> > +
> >
> > if (LzInWindow_Create(p, sizeReserv, alloc))
> >
> > {
> >
> > UInt32 newCyclicBufferSize = historySize + 1;
> >
> > @@ -243,7 +243,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
> > p->historySize = historySize;
> >
> > p->hashSizeSum = hs;
> >
> > p->cyclicBufferSize = newCyclicBufferSize;
> >
> > -
> >
> > +
> >
> > numSons = newCyclicBufferSize;
> >
> > if (p->btMode)
> >
> > numSons <<= 1;
> >
> > @@ -251,11 +251,11 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
> >
> >
> > if (p->hash && p->numRefs == newSize)
> >
> > return 1;
> >
> > -
> >
> > +
> >
> > MatchFinder_FreeThisClassMemory(p, alloc);
> >
> > p->numRefs = newSize;
> >
> > p->hash = AllocRefs(newSize, alloc);
> >
> > -
> >
> > +
> >
> > if (p->hash)
> >
> > {
> >
> > p->son = p->hash + p->hashSizeSum;
> >
> > @@ -272,11 +272,11 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
> > {
> >
> > UInt32 limit = kMaxValForNormalize - p->pos;
> >
> > UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
> >
> > -
> >
> > +
> >
> > if (limit2 < limit)
> >
> > limit = limit2;
> >
> > limit2 = p->streamPos - p->pos;
> >
> > -
> >
> > +
> >
> > if (limit2 <= p->keepSizeAfter)
> >
> > {
> >
> > if (limit2 > 0)
> >
> > @@ -284,10 +284,10 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
> > }
> >
> > else
> >
> > limit2 -= p->keepSizeAfter;
> >
> > -
> >
> > +
> >
> > if (limit2 < limit)
> >
> > limit = limit2;
> >
> > -
> >
> > +
> >
> > {
> >
> > UInt32 lenLimit = p->streamPos - p->pos;
> >
> > if (lenLimit > p->matchMaxLen)
> >
> > @@ -326,10 +326,10 @@ void MatchFinder_Init_3(CMatchFinder *p, int readData)
> > p->streamPos = p->cyclicBufferSize;
> >
> > p->result = SZ_OK;
> >
> > p->streamEndWasReached = 0;
> >
> > -
> >
> > +
> >
> > if (readData)
> >
> > MatchFinder_ReadBlock(p);
> >
> > -
> >
> > +
> >
> > MatchFinder_SetLimits(p);
> >
> > }
> >
> >
> >
> > @@ -341,7 +341,7 @@ void MatchFinder_Init(CMatchFinder *p)
> > MatchFinder_Init_3(p, True);
> >
> > }
> >
> >
> >
> > -
> >
> > +
> >
> > static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
> >
> > {
> >
> > return (p->pos - p->historySize - 1) & kNormalizeMask;
> >
> > @@ -584,7 +584,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > d2 = pos - hash[h2];
> >
> >
> >
> > curMatch = (hash + kFix3HashSize)[hv];
> >
> > -
> >
> > +
> >
> > hash[h2] = pos;
> >
> > (hash + kFix3HashSize)[hv] = pos;
> >
> >
> >
> > @@ -603,7 +603,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > MOVE_POS_RET;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > GET_MATCHES_FOOTER(offset, maxLen)
> >
> > }
> >
> >
> >
> > @@ -629,14 +629,14 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> >
> >
> > maxLen = 0;
> >
> > offset = 0;
> >
> > -
> >
> > +
> >
> > if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
> >
> > {
> >
> > distances[0] = maxLen = 2;
> >
> > distances[1] = d2 - 1;
> >
> > offset = 2;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
> >
> > {
> >
> > maxLen = 3;
> >
> > @@ -644,7 +644,7 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset += 2;
> >
> > d2 = d3;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (offset != 0)
> >
> > {
> >
> > UPDATE_maxLen
> >
> > @@ -655,10 +655,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > MOVE_POS_RET;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if (maxLen < 3)
> >
> > maxLen = 3;
> >
> > -
> >
> > +
> >
> > GET_MATCHES_FOOTER(offset, maxLen)
> >
> > }
> >
> >
> >
> > @@ -710,7 +710,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset = 2;
> >
> > d2 = d3;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (d2 != d4 && d4 < p->cyclicBufferSize
> >
> > && *(cur - d4) == *cur
> >
> > && *(cur - d4 + 3) == *(cur + 3))
> >
> > @@ -720,7 +720,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset += 2;
> >
> > d2 = d4;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (offset != 0)
> >
> > {
> >
> > UPDATE_maxLen
> >
> > @@ -734,7 +734,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> >
> >
> > if (maxLen < 4)
> >
> > maxLen = 4;
> >
> > -
> >
> > +
> >
> > GET_MATCHES_FOOTER(offset, maxLen)
> >
> > }
> >
> > */
> >
> > @@ -749,10 +749,10 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> >
> >
> > hash = p->hash;
> >
> > pos = p->pos;
> >
> > -
> >
> > +
> >
> > d2 = pos - hash[ h2];
> >
> > d3 = pos - (hash + kFix3HashSize)[h3];
> >
> > -
> >
> > +
> >
> > curMatch = (hash + kFix4HashSize)[hv];
> >
> >
> >
> > hash[ h2] = pos;
> >
> > @@ -768,7 +768,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > distances[1] = d2 - 1;
> >
> > offset = 2;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
> >
> > {
> >
> > maxLen = 3;
> >
> > @@ -776,7 +776,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset += 2;
> >
> > d2 = d3;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (offset != 0)
> >
> > {
> >
> > UPDATE_maxLen
> >
> > @@ -787,7 +787,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > MOVE_POS_RET;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if (maxLen < 3)
> >
> > maxLen = 3;
> >
> >
> >
> > @@ -807,7 +807,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> >
> >
> > hash = p->hash;
> >
> > pos = p->pos;
> >
> > -
> >
> > +
> >
> > d2 = pos - hash[ h2];
> >
> > d3 = pos - (hash + kFix3HashSize)[h3];
> >
> > d4 = pos - (hash + kFix4HashSize)[h4];
> >
> > @@ -844,7 +844,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset = 2;
> >
> > d2 = d3;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (d2 != d4 && d4 < p->cyclicBufferSize
> >
> > && *(cur - d4) == *cur
> >
> > && *(cur - d4 + 3) == *(cur + 3))
> >
> > @@ -854,7 +854,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > offset += 2;
> >
> > d2 = d4;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (offset != 0)
> >
> > {
> >
> > UPDATE_maxLen
> >
> > @@ -865,7 +865,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
> > MOVE_POS_RET;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if (maxLen < 4)
> >
> > maxLen = 4;
> >
> >
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
> > index c77added7bd3..61bb9dd302b5 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
> > @@ -34,7 +34,7 @@ typedef struct _CMatchFinder
> >
> >
> > Byte *bufferBase;
> >
> > ISeqInStream *stream;
> >
> > -
> >
> > +
> >
> > UInt32 blockSize;
> >
> > UInt32 keepSizeBefore;
> >
> > UInt32 keepSizeAfter;
> >
> > @@ -59,7 +59,7 @@ typedef struct _CMatchFinder
> > ((p)->streamEndWasReached \
> >
> > && (p)->streamPos == (p)->pos \
> >
> > && (!(p)->directInput || (p)->directInputRem == 0))
> >
> > -
> >
> > +
> >
> > int MatchFinder_NeedMove(CMatchFinder *p);
> >
> > Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
> >
> > void MatchFinder_MoveBlock(CMatchFinder *p);
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
> > index 2563824fcdef..8e7cf6493ce3 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
> > @@ -62,7 +62,7 @@ static void MtSync_StopWriting(CMtSync *p)
> > p->csWasEntered = False;
> >
> > }
> >
> > Semaphore_Release1(&p->freeSemaphore);
> >
> > -
> >
> > +
> >
> > Event_Wait(&p->wasStopped);
> >
> >
> >
> > while (myNumBlocks++ != p->numProcessedBlocks)
> >
> > @@ -112,12 +112,12 @@ static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj,
> > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart));
> >
> > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStarted));
> >
> > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped));
> >
> > -
> >
> > +
> >
> > RINOK_THREAD(Semaphore_Create(&p->freeSemaphore, numBlocks, numBlocks));
> >
> > RINOK_THREAD(Semaphore_Create(&p->filledSemaphore, 0, numBlocks));
> >
> >
> >
> > p->needStart = True;
> >
> > -
> >
> > +
> >
> > RINOK_THREAD(Thread_Create(&p->thread, startAddress, obj));
> >
> > p->wasCreated = True;
> >
> > return SZ_OK;
> >
> > @@ -320,9 +320,9 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
> > UInt32 numProcessed = 0;
> >
> > UInt32 curPos = 2;
> >
> > UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2);
> >
> > -
> >
> > +
> >
> > distances[1] = p->hashNumAvail;
> >
> > -
> >
> > +
> >
> > while (curPos < limit)
> >
> > {
> >
> > if (p->hashBufPos == p->hashBufPosLimit)
> >
> > @@ -352,7 +352,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
> > if (size2 < size)
> >
> > size = size2;
> >
> > }
> >
> > -
> >
> > +
> >
> > #ifndef MFMT_GM_INLINE
> >
> > while (curPos < limit && size-- != 0)
> >
> > {
> >
> > @@ -386,7 +386,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
> > p->cyclicBufferPos = cyclicBufferPos;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > distances[0] = curPos;
> >
> > }
> >
> >
> >
> > @@ -398,7 +398,7 @@ static void BtFillBlock(CMatchFinderMt *p, UInt32 globalBlockIndex)
> > CriticalSection_Enter(&sync->cs);
> >
> > sync->csWasEntered = True;
> >
> > }
> >
> > -
> >
> > +
> >
> > BtGetMatches(p, p->btBuf + (globalBlockIndex & kMtBtNumBlocksMask) * kMtBtBlockSize);
> >
> >
> >
> > if (p->pos > kMtMaxValForNormalize - kMtBtBlockSize)
> >
> > @@ -504,7 +504,7 @@ SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddB
> > static void MatchFinderMt_Init(CMatchFinderMt *p)
> >
> > {
> >
> > CMatchFinder *mf = p->MatchFinder;
> >
> > -
> >
> > +
> >
> > p->btBufPos =
> >
> > p->btBufPosLimit = 0;
> >
> > p->hashBufPos =
> >
> > @@ -513,7 +513,7 @@ static void MatchFinderMt_Init(CMatchFinderMt *p)
> > /* Init without data reading. We don't want to read data in this thread */
> >
> > MatchFinder_Init_3(mf, False);
> >
> > MatchFinder_Init_LowHash(mf);
> >
> > -
> >
> > +
> >
> > p->pointerToCurPos = Inline_MatchFinder_GetPointerToCurrentPos(mf);
> >
> > p->btNumAvailBytes = 0;
> >
> > p->lzPos = p->historySize + 1;
> >
> > @@ -577,7 +577,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
> > const Byte *cur = p->pointerToCurPos;
> >
> > UInt32 lzPos = p->lzPos;
> >
> > MT_HASH2_CALC
> >
> > -
> >
> > +
> >
> > curMatch2 = hash[h2];
> >
> > hash[h2] = lzPos;
> >
> >
> >
> > @@ -587,7 +587,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
> > *distances++ = 2;
> >
> > *distances++ = lzPos - curMatch2 - 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > return distances;
> >
> > }
> >
> >
> >
> > @@ -601,7 +601,7 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
> >
> >
> > curMatch2 = hash[ h2];
> >
> > curMatch3 = (hash + kFix3HashSize)[h3];
> >
> > -
> >
> > +
> >
> > hash[ h2] = lzPos;
> >
> > (hash + kFix3HashSize)[h3] = lzPos;
> >
> >
> >
> > @@ -616,13 +616,13 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
> > distances[0] = 2;
> >
> > distances += 2;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
> >
> > {
> >
> > *distances++ = 3;
> >
> > *distances++ = lzPos - curMatch3 - 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > return distances;
> >
> > }
> >
> >
> >
> > @@ -634,11 +634,11 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
> > const Byte *cur = p->pointerToCurPos;
> >
> > UInt32 lzPos = p->lzPos;
> >
> > MT_HASH4_CALC
> >
> > -
> >
> > +
> >
> > curMatch2 = hash[ h2];
> >
> > curMatch3 = (hash + kFix3HashSize)[h3];
> >
> > curMatch4 = (hash + kFix4HashSize)[h4];
> >
> > -
> >
> > +
> >
> > hash[ h2] = lzPos;
> >
> > (hash + kFix3HashSize)[h3] = lzPos;
> >
> > (hash + kFix4HashSize)[h4] = lzPos;
> >
> > @@ -654,7 +654,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
> > distances[0] = 2;
> >
> > distances += 2;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
> >
> > {
> >
> > distances[1] = lzPos - curMatch3 - 1;
> >
> > @@ -676,7 +676,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
> > *distances++ = 4;
> >
> > *distances++ = lzPos - curMatch4 - 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > return distances;
> >
> > }
> >
> > */
> >
> > @@ -789,7 +789,7 @@ void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable)
> > vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinderMt_GetNumAvailableBytes;
> >
> > vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinderMt_GetPointerToCurrentPos;
> >
> > vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches;
> >
> > -
> >
> > +
> >
> > switch (p->MatchFinder->numHashBytes)
> >
> > {
> >
> > case 2:
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
> > index 3d86c788f3f9..b1398a883aaf 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
> > @@ -60,7 +60,7 @@ typedef struct _CMatchFinderMt
> > const UInt32 *crc;
> >
> >
> >
> > Mf_Mix_Matches MixMatchesFunc;
> >
> > -
> >
> > +
> >
> > /* LZ + BT */
> >
> > CMtSync btSync;
> >
> > Byte btDummy[kMtCacheLineDummy];
> >
> > @@ -83,7 +83,7 @@ typedef struct _CMatchFinderMt
> > /* BT + Hash */
> >
> > CMtSync hashSync;
> >
> > /* Byte hashDummy[kMtCacheLineDummy]; */
> >
> > -
> >
> > +
> >
> > /* Hash */
> >
> > Mf_GetHeads GetHeadsFunc;
> >
> > CMatchFinder *MatchFinder;
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
> > index 962b94bb6338..6328c9011aa0 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
> > @@ -227,7 +227,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > Byte *dic = p->dic;
> >
> > SizeT dicBufSize = p->dicBufSize;
> >
> > SizeT dicPos = p->dicPos;
> >
> > -
> >
> > +
> >
> > UInt32 processedPos = p->processedPos;
> >
> > UInt32 checkDicSize = p->checkDicSize;
> >
> > unsigned len = 0;
> >
> > @@ -303,7 +303,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > dic[dicPos++] = (Byte)symbol;
> >
> > continue;
> >
> > }
> >
> > -
> >
> > +
> >
> > {
> >
> > UPDATE_1(prob);
> >
> > prob = probs + IsRep + state;
> >
> > @@ -370,7 +370,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > state = state < kNumLitStates ? 8 : 11;
> >
> > prob = probs + RepLenCoder;
> >
> > }
> >
> > -
> >
> > +
> >
> > #ifdef _LZMA_SIZE_OPT
> >
> > {
> >
> > unsigned lim, offset;
> >
> > @@ -474,7 +474,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > {
> >
> > NORMALIZE
> >
> > range >>= 1;
> >
> > -
> >
> > +
> >
> > {
> >
> > UInt32 t;
> >
> > code -= range;
> >
> > @@ -510,7 +510,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > }
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > rep3 = rep2;
> >
> > rep2 = rep1;
> >
> > rep1 = rep0;
> >
> > @@ -529,13 +529,13 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > SizeT rem;
> >
> > unsigned curLen;
> >
> > SizeT pos;
> >
> > -
> >
> > +
> >
> > if ((rem = limit - dicPos) == 0)
> >
> > {
> >
> > p->dicPos = dicPos;
> >
> > return SZ_ERROR_DATA;
> >
> > }
> >
> > -
> >
> > +
> >
> > curLen = ((rem < len) ? (unsigned)rem : len);
> >
> > pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
> >
> >
> >
> > @@ -568,7 +568,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
> > while (dicPos < limit && buf < bufLimit);
> >
> >
> >
> > NORMALIZE;
> >
> > -
> >
> > +
> >
> > p->buf = buf;
> >
> > p->range = range;
> >
> > p->code = code;
> >
> > @@ -638,10 +638,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte
> > }
> >
> >
> >
> > RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit));
> >
> > -
> >
> > +
> >
> > if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
> >
> > p->checkDicSize = p->prop.dicSize;
> >
> > -
> >
> > +
> >
> > LzmaDec_WriteRem(p, limit);
> >
> > }
> >
> > while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
> >
> > @@ -877,7 +877,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
> > {
> >
> > SizeT inSize = *srcLen;
> >
> > (*srcLen) = 0;
> >
> > -
> >
> > +
> >
> > *status = LZMA_STATUS_NOT_SPECIFIED;
> >
> >
> >
> > if (p->remainLen > kMatchSpecLenStart)
> >
> > @@ -995,7 +995,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
> > p->buf = p->tempBuf;
> >
> > if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
> >
> > return SZ_ERROR_DATA;
> >
> > -
> >
> > +
> >
> > {
> >
> > unsigned kkk = (unsigned)(p->buf - p->tempBuf);
> >
> > if (rem < kkk)
> >
> > @@ -1011,7 +1011,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
> > p->tempBufSize = 0;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if (p->code != 0)
> >
> > return SZ_ERROR_DATA;
> >
> > *status = LZMA_STATUS_FINISHED_WITH_MARK;
> >
> > @@ -1081,12 +1081,12 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
> > {
> >
> > UInt32 dicSize;
> >
> > Byte d;
> >
> > -
> >
> > +
> >
> > if (size < LZMA_PROPS_SIZE)
> >
> > return SZ_ERROR_UNSUPPORTED;
> >
> > else
> >
> > dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
> >
> > -
> >
> > +
> >
> > if (dicSize < LZMA_DIC_MIN)
> >
> > dicSize = LZMA_DIC_MIN;
> >
> > p->dicSize = dicSize;
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
> > index 28ce60c3ea94..ebc568cb4ff4 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
> > @@ -135,7 +135,7 @@ LzmaDec_Allocate* can return:
> > SZ_ERROR_MEM - Memory allocation error
> >
> > SZ_ERROR_UNSUPPORTED - Unsupported properties
> >
> > */
> >
> > -
> >
> > +
> >
> > SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
> >
> > void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);
> >
> >
> >
> > @@ -164,7 +164,7 @@ void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
> > */
> >
> >
> >
> > /* LzmaDec_DecodeToDic
> >
> > -
> >
> > +
> >
> > The decoding to internal dictionary buffer (CLzmaDec::dic).
> >
> > You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
> >
> >
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
> > index e281716fee1b..d7931cd73799 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
> > @@ -52,7 +52,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
> > int level = p->level;
> >
> > if (level < 0) level = 5;
> >
> > p->level = level;
> >
> > -
> >
> > +
> >
> > if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26)));
> >
> > if (p->dictSize > p->reduceSize)
> >
> > {
> >
> > @@ -74,7 +74,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
> > if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
> >
> > if (p->numHashBytes < 0) p->numHashBytes = 4;
> >
> > if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
> >
> > -
> >
> > +
> >
> > if (p->numThreads < 0)
> >
> > p->numThreads =
> >
> > #ifndef _7ZIP_ST
> >
> > @@ -124,7 +124,7 @@ static void LzmaEnc_FastPosInit(Byte *g_FastPos)
> > g_FastPos[0] = 0;
> >
> > g_FastPos[1] = 1;
> >
> > g_FastPos += 2;
> >
> > -
> >
> > +
> >
> > for (slot = 2; slot < kNumLogBits * 2; slot++)
> >
> > {
> >
> > size_t k = ((size_t)1 << ((slot >> 1) - 1));
> >
> > @@ -273,7 +273,7 @@ typedef struct
> >
> >
> > CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
> >
> > CLzmaProb posEncoders[kNumFullDistances];
> >
> > -
> >
> > +
> >
> > CLenEnc lenProbs;
> >
> > CLenEnc repLenProbs;
> >
> >
> >
> > @@ -315,7 +315,7 @@ typedef struct
> > Bool needInit;
> >
> >
> >
> > UInt64 nowPos64;
> >
> > -
> >
> > +
> >
> > unsigned matchPriceCount;
> >
> > unsigned alignPriceCount;
> >
> >
> >
> > @@ -336,7 +336,7 @@ typedef struct
> > #ifndef _7ZIP_ST
> >
> > Byte pad[128];
> >
> > #endif
> >
> > -
> >
> > +
> >
> > // LZ thread
> >
> > CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
> >
> >
> >
> > @@ -355,7 +355,7 @@ typedef struct
> > CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
> >
> > CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
> >
> > CLzmaProb posEncoders[kNumFullDistances];
> >
> > -
> >
> > +
> >
> > CLenEnc lenProbs;
> >
> > CLenEnc repLenProbs;
> >
> >
> >
> > @@ -383,9 +383,9 @@ void LzmaEnc_SaveState(CLzmaEncHandle pp)
> > {
> >
> > CLzmaEnc *p = (CLzmaEnc *)pp;
> >
> > CSaveState *dest = &p->saveState;
> >
> > -
> >
> > +
> >
> > dest->state = p->state;
> >
> > -
> >
> > +
> >
> > dest->lenProbs = p->lenProbs;
> >
> > dest->repLenProbs = p->repLenProbs;
> >
> >
> >
> > @@ -414,9 +414,9 @@ void LzmaEnc_RestoreState(CLzmaEncHandle pp)
> >
> >
> > dest->lenProbs = p->lenProbs;
> >
> > dest->repLenProbs = p->repLenProbs;
> >
> > -
> >
> > +
> >
> > COPY_ARR(dest, p, reps);
> >
> > -
> >
> > +
> >
> > COPY_ARR(dest, p, posAlignEncoder);
> >
> > COPY_ARR(dest, p, isRep);
> >
> > COPY_ARR(dest, p, isRepG0);
> >
> > @@ -914,7 +914,7 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates,
> > printf("\n MovePos %u", num);
> >
> > #endif
> >
> > */
> >
> > -
> >
> > +
> >
> > #define MOVE_POS(p, num) { \
> >
> > p->additionalOffset += (num); \
> >
> > p->matchFinder.Skip(p->matchFinderObj, (num)); }
> >
> > @@ -923,12 +923,12 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates,
> > static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
> >
> > {
> >
> > unsigned numPairs;
> >
> > -
> >
> > +
> >
> > p->additionalOffset++;
> >
> > p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
> >
> > numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
> >
> > *numPairsRes = numPairs;
> >
> > -
> >
> > +
> >
> > #ifdef SHOW_STAT
> >
> > printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2);
> >
> > g_STAT_OFFSET++;
> >
> > @@ -938,7 +938,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
> > printf("%2u %6u | ", p->matches[i], p->matches[i + 1]);
> >
> > }
> >
> > #endif
> >
> > -
> >
> > +
> >
> > if (numPairs == 0)
> >
> > return 0;
> >
> > {
> >
> > @@ -976,7 +976,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
> > + GET_PRICE_1(p->isRep0Long[state][posState])) \
> >
> > + GET_PRICE_1(p->isRep[state]) \
> >
> > + GET_PRICE_0(p->isRepG0[state])
> >
> > -
> >
> > +
> >
> >
> >
> > static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)
> >
> > {
> >
> > @@ -1042,7 +1042,7 @@ static unsigned Backward(CLzmaEnc *p, unsigned cur)
> > p->optCur = wr;
> >
> > return len;
> >
> > }
> >
> > -
> >
> > +
> >
> > wr--;
> >
> > p->opt[wr].dist = dist;
> >
> > p->opt[wr].len = len;
> >
> > @@ -1068,9 +1068,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > UInt32 matchPrice, repMatchPrice;
> >
> > const Byte *data;
> >
> > Byte curByte, matchByte;
> >
> > -
> >
> > +
> >
> > p->optCur = p->optEnd = 0;
> >
> > -
> >
> > +
> >
> > if (p->additionalOffset == 0)
> >
> > mainLen = ReadMatchDistances(p, &numPairs);
> >
> > else
> >
> > @@ -1078,7 +1078,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > mainLen = p->longestMatchLen;
> >
> > numPairs = p->numPairs;
> >
> > }
> >
> > -
> >
> > +
> >
> > numAvail = p->numAvail;
> >
> > if (numAvail < 2)
> >
> > {
> >
> > @@ -1087,10 +1087,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > if (numAvail > LZMA_MATCH_LEN_MAX)
> >
> > numAvail = LZMA_MATCH_LEN_MAX;
> >
> > -
> >
> > +
> >
> > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
> >
> > repMaxIndex = 0;
> >
> > -
> >
> > +
> >
> > for (i = 0; i < LZMA_NUM_REPS; i++)
> >
> > {
> >
> > unsigned len;
> >
> > @@ -1107,7 +1107,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > if (len > repLens[repMaxIndex])
> >
> > repMaxIndex = i;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (repLens[repMaxIndex] >= p->numFastBytes)
> >
> > {
> >
> > unsigned len;
> >
> > @@ -1116,29 +1116,29 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > MOVE_POS(p, len - 1)
> >
> > return len;
> >
> > }
> >
> > -
> >
> > +
> >
> > matches = p->matches;
> >
> > -
> >
> > +
> >
> > if (mainLen >= p->numFastBytes)
> >
> > {
> >
> > p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
> >
> > MOVE_POS(p, mainLen - 1)
> >
> > return mainLen;
> >
> > }
> >
> > -
> >
> > +
> >
> > curByte = *data;
> >
> > matchByte = *(data - reps[0]);
> >
> > -
> >
> > +
> >
> > if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < 2)
> >
> > {
> >
> > p->backRes = MARK_LIT;
> >
> > return 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > p->opt[0].state = (CState)p->state;
> >
> > -
> >
> > +
> >
> > posState = (position & p->pbMask);
> >
> > -
> >
> > +
> >
> > {
> >
> > const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
> >
> > p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +
> >
> > @@ -1146,12 +1146,12 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
> >
> > LitEnc_GetPrice(probs, curByte, p->ProbPrices));
> >
> > }
> >
> > -
> >
> > +
> >
> > MakeAs_Lit(&p->opt[1]);
> >
> > -
> >
> > +
> >
> > matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
> >
> > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
> >
> > -
> >
> > +
> >
> > if (matchByte == curByte)
> >
> > {
> >
> > UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState);
> >
> > @@ -1161,22 +1161,22 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > MakeAs_ShortRep(&p->opt[1]);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > last = (mainLen >= repLens[repMaxIndex] ? mainLen : repLens[repMaxIndex]);
> >
> > -
> >
> > +
> >
> > if (last < 2)
> >
> > {
> >
> > p->backRes = p->opt[1].dist;
> >
> > return 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > p->opt[1].len = 1;
> >
> > -
> >
> > +
> >
> > p->opt[0].reps[0] = reps[0];
> >
> > p->opt[0].reps[1] = reps[1];
> >
> > p->opt[0].reps[2] = reps[2];
> >
> > p->opt[0].reps[3] = reps[3];
> >
> > -
> >
> > +
> >
> > {
> >
> > unsigned len = last;
> >
> > do
> >
> > @@ -1185,7 +1185,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> >
> >
> > // ---------- REP ----------
> >
> > -
> >
> > +
> >
> > for (i = 0; i < LZMA_NUM_REPS; i++)
> >
> > {
> >
> > unsigned repLen = repLens[i];
> >
> > @@ -1207,8 +1207,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > while (--repLen >= 2);
> >
> > }
> >
> > -
> >
> > -
> >
> > +
> >
> > +
> >
> > // ---------- MATCH ----------
> >
> > {
> >
> > unsigned len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
> >
> > @@ -1219,14 +1219,14 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> >
> >
> > while (len > matches[offs])
> >
> > offs += 2;
> >
> > -
> >
> > +
> >
> > for (; ; len++)
> >
> > {
> >
> > COptimal *opt;
> >
> > UInt32 dist = matches[(size_t)offs + 1];
> >
> > UInt32 price2 = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];
> >
> > unsigned lenToPosState = GetLenToPosState(len);
> >
> > -
> >
> > +
> >
> > if (dist < kNumFullDistances)
> >
> > price2 += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
> >
> > else
> >
> > @@ -1236,9 +1236,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > price2 += p->alignPrices[dist & kAlignMask];
> >
> > price2 += p->posSlotPrices[lenToPosState][slot];
> >
> > }
> >
> > -
> >
> > +
> >
> > opt = &p->opt[len];
> >
> > -
> >
> > +
> >
> > if (price2 < opt->price)
> >
> > {
> >
> > opt->price = price2;
> >
> > @@ -1246,7 +1246,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > opt->dist = dist + LZMA_NUM_REPS;
> >
> > opt->extra = 0;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (len == matches[offs])
> >
> > {
> >
> > offs += 2;
> >
> > @@ -1256,7 +1256,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> >
> >
> > cur = 0;
> >
> >
> >
> > @@ -1272,7 +1272,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> >
> >
> >
> >
> > -
> >
> > +
> >
> > // ---------- Optimal Parsing ----------
> >
> >
> >
> > for (;;)
> >
> > @@ -1289,17 +1289,17 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > return Backward(p, cur);
> >
> >
> >
> > newLen = ReadMatchDistances(p, &numPairs);
> >
> > -
> >
> > +
> >
> > if (newLen >= p->numFastBytes)
> >
> > {
> >
> > p->numPairs = numPairs;
> >
> > p->longestMatchLen = newLen;
> >
> > return Backward(p, cur);
> >
> > }
> >
> > -
> >
> > +
> >
> > curOpt = &p->opt[cur];
> >
> > prev = cur - curOpt->len;
> >
> > -
> >
> > +
> >
> > if (curOpt->len == 1)
> >
> > {
> >
> > state = p->opt[prev].state;
> >
> > @@ -1368,7 +1368,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > reps[3] = prevOpt->reps[2];
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > curOpt->state = (CState)state;
> >
> > curOpt->reps[0] = reps[0];
> >
> > curOpt->reps[1] = reps[1];
> >
> > @@ -1403,7 +1403,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > litPrice += (!IsLitState(state) ?
> >
> > LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
> >
> > LitEnc_GetPrice(probs, curByte, p->ProbPrices));
> >
> > -
> >
> > +
> >
> > if (litPrice < nextOpt->price)
> >
> > {
> >
> > nextOpt->price = litPrice;
> >
> > @@ -1415,7 +1415,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> >
> >
> > matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]);
> >
> > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);
> >
> > -
> >
> > +
> >
> > // ---------- SHORT_REP ----------
> >
> > // if (IsLitState(state)) // 18.new
> >
> > if (matchByte == curByte)
> >
> > @@ -1435,7 +1435,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > nextIsLit = False;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > numAvailFull = p->numAvail;
> >
> > {
> >
> > UInt32 temp = kNumOpts - 1 - cur;
> >
> > @@ -1467,7 +1467,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > for (len = 3; len < limit && data[len] == data2[len]; len++)
> >
> > {
> >
> > }
> >
> > -
> >
> > +
> >
> > {
> >
> > unsigned state2 = kLiteralNextStates[state];
> >
> > unsigned posState2 = (position + 1) & p->pbMask;
> >
> > @@ -1476,7 +1476,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > unsigned offset = cur + len;
> >
> > while (last < offset)
> >
> > p->opt[++last].price = kInfinityPrice;
> >
> > -
> >
> > +
> >
> > // do
> >
> > {
> >
> > UInt32 price2;
> >
> > @@ -1500,7 +1500,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > startLen = 2; /* speed optimization */
> >
> > {
> >
> > // ---------- REP ----------
> >
> > @@ -1513,9 +1513,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > const Byte *data2 = data - reps[repIndex];
> >
> > if (data[0] != data2[0] || data[1] != data2[1])
> >
> > continue;
> >
> > -
> >
> > +
> >
> > for (len = 2; len < numAvail && data[len] == data2[len]; len++);
> >
> > -
> >
> > +
> >
> > // if (len < startLen) continue; // 18.new: speed optimization
> >
> >
> >
> > while (last < cur + len)
> >
> > @@ -1537,7 +1537,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > while (--len2 >= 2);
> >
> > }
> >
> > -
> >
> > +
> >
> > if (repIndex == 0) startLen = len + 1; // 17.old
> >
> > // startLen = len + 1; // 18.new
> >
> >
> >
> > @@ -1550,9 +1550,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > unsigned limit = len2 + p->numFastBytes;
> >
> > if (limit > numAvailFull)
> >
> > limit = numAvailFull;
> >
> > -
> >
> > +
> >
> > for (; len2 < limit && data[len2] == data2[len2]; len2++);
> >
> > -
> >
> > +
> >
> > len2 -= len;
> >
> > if (len2 >= 3)
> >
> > {
> >
> > @@ -1563,7 +1563,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > + GET_PRICE_0(p->isMatch[state2][posState2])
> >
> > + LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
> >
> > data[len], data2[len], p->ProbPrices);
> >
> > -
> >
> > +
> >
> > // state2 = kLiteralNextStates[state2];
> >
> > state2 = kState_LitAfterRep;
> >
> > posState2 = (posState2 + 1) & p->pbMask;
> >
> > @@ -1609,7 +1609,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > matches[numPairs] = newLen;
> >
> > numPairs += 2;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (newLen >= startLen)
> >
> > {
> >
> > UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
> >
> > @@ -1622,10 +1622,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > while (startLen > matches[offs])
> >
> > offs += 2;
> >
> > dist = matches[(size_t)offs + 1];
> >
> > -
> >
> > +
> >
> > // if (dist >= kNumFullDistances)
> >
> > GetPosSlot2(dist, posSlot);
> >
> > -
> >
> > +
> >
> > for (len = /*2*/ startLen; ; len++)
> >
> > {
> >
> > UInt32 price = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];
> >
> > @@ -1636,7 +1636,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
> >
> > else
> >
> > price += p->posSlotPrices[lenToPosState][posSlot] + p->alignPrices[dist & kAlignMask];
> >
> > -
> >
> > +
> >
> > opt = &p->opt[cur + len];
> >
> > if (price < opt->price)
> >
> > {
> >
> > @@ -1656,11 +1656,11 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > unsigned limit = len2 + p->numFastBytes;
> >
> > if (limit > numAvailFull)
> >
> > limit = numAvailFull;
> >
> > -
> >
> > +
> >
> > for (; len2 < limit && data[len2] == data2[len2]; len2++);
> >
> > -
> >
> > +
> >
> > len2 -= len;
> >
> > -
> >
> > +
> >
> > if (len2 >= 3)
> >
> > {
> >
> > unsigned state2 = kMatchNextStates[state];
> >
> > @@ -1698,7 +1698,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
> > }
> >
> > // while (len2 >= 3);
> >
> > }
> >
> > -
> >
> > +
> >
> > offs += 2;
> >
> > if (offs == numPairs)
> >
> > break;
> >
> > @@ -1739,7 +1739,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
> > numAvail = LZMA_MATCH_LEN_MAX;
> >
> > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
> >
> > repLen = repIndex = 0;
> >
> > -
> >
> > +
> >
> > for (i = 0; i < LZMA_NUM_REPS; i++)
> >
> > {
> >
> > unsigned len;
> >
> > @@ -1768,7 +1768,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
> > }
> >
> >
> >
> > mainDist = 0; /* for GCC */
> >
> > -
> >
> > +
> >
> > if (mainLen >= 2)
> >
> > {
> >
> > mainDist = p->matches[(size_t)numPairs - 1];
> >
> > @@ -1797,14 +1797,14 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
> > MOVE_POS(p, repLen - 1)
> >
> > return repLen;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (mainLen < 2 || numAvail <= 2)
> >
> > return 1;
> >
> >
> >
> > {
> >
> > unsigned len1 = ReadMatchDistances(p, &p->numPairs);
> >
> > p->longestMatchLen = len1;
> >
> > -
> >
> > +
> >
> > if (len1 >= 2)
> >
> > {
> >
> > UInt32 newDist = p->matches[(size_t)p->numPairs - 1];
> >
> > @@ -1815,9 +1815,9 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
> > return 1;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
> >
> > -
> >
> > +
> >
> > for (i = 0; i < LZMA_NUM_REPS; i++)
> >
> > {
> >
> > unsigned len, limit;
> >
> > @@ -1833,7 +1833,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
> > break;
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > p->backRes = mainDist + LZMA_NUM_REPS;
> >
> > if (mainLen != 2)
> >
> > {
> >
> > @@ -1859,7 +1859,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
> > RC_BIT_0(&p->rc, prob)
> >
> > }
> >
> > p->state = kMatchNextStates[p->state];
> >
> > -
> >
> > +
> >
> > p->rc.range = range;
> >
> > LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState);
> >
> > range = p->rc.range;
> >
> > @@ -1888,7 +1888,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
> > }
> >
> > while (--numBits);
> >
> > }
> >
> > -
> >
> > +
> >
> > {
> >
> > // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
> >
> > CLzmaProb *probs = p->posAlignEncoder;
> >
> > @@ -2037,7 +2037,7 @@ void LzmaEnc_Construct(CLzmaEnc *p)
> > {
> >
> > RangeEnc_Construct(&p->rc);
> >
> > MatchFinder_Construct(&p->matchFinderBase);
> >
> > -
> >
> > +
> >
> > #ifndef _7ZIP_ST
> >
> > MatchFinderMt_Construct(&p->matchFinderMt);
> >
> > p->matchFinderMt.MatchFinder = &p->matchFinderBase;
> >
> > @@ -2081,7 +2081,7 @@ void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
> > #ifndef _7ZIP_ST
> >
> > MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
> >
> > #endif
> >
> > -
> >
> > +
> >
> > MatchFinder_Free(&p->matchFinderBase, allocBig);
> >
> > LzmaEnc_FreeLits(p, alloc);
> >
> > RangeEnc_Free(&p->rc, alloc);
> >
> > @@ -2126,14 +2126,14 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > }
> >
> >
> >
> > if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
> >
> > -
> >
> > +
> >
> > for (;;)
> >
> > {
> >
> > UInt32 dist;
> >
> > unsigned len, posState;
> >
> > UInt32 range, ttt, newBound;
> >
> > CLzmaProb *probs;
> >
> > -
> >
> > +
> >
> > if (p->fastMode)
> >
> > len = GetOptimumFast(p);
> >
> > else
> >
> > @@ -2153,9 +2153,9 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > posState = (unsigned)nowPos32 & p->pbMask;
> >
> > range = p->rc.range;
> >
> > probs = &p->isMatch[p->state][posState];
> >
> > -
> >
> > +
> >
> > RC_BIT_PRE(&p->rc, probs)
> >
> > -
> >
> > +
> >
> > dist = p->backRes;
> >
> >
> >
> > #ifdef SHOW_STAT2
> >
> > @@ -2185,7 +2185,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > RC_BIT_1(&p->rc, probs);
> >
> > probs = &p->isRep[p->state];
> >
> > RC_BIT_PRE(&p->rc, probs)
> >
> > -
> >
> > +
> >
> > if (dist < LZMA_NUM_REPS)
> >
> > {
> >
> > RC_BIT_1(&p->rc, probs);
> >
> > @@ -2269,7 +2269,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > p->reps[2] = p->reps[1];
> >
> > p->reps[1] = p->reps[0];
> >
> > p->reps[0] = dist + 1;
> >
> > -
> >
> > +
> >
> > p->matchPriceCount++;
> >
> > GetPosSlot(dist, posSlot);
> >
> > // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);
> >
> > @@ -2287,7 +2287,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > while (symbol < (1 << kNumPosSlotBits * 2));
> >
> > p->rc.range = range;
> >
> > }
> >
> > -
> >
> > +
> >
> > if (dist >= kStartPosModelIndex)
> >
> > {
> >
> > unsigned footerBits = ((posSlot >> 1) - 1);
> >
> > @@ -2340,7 +2340,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> >
> >
> > nowPos32 += len;
> >
> > p->additionalOffset -= len;
> >
> > -
> >
> > +
> >
> > if (p->additionalOffset == 0)
> >
> > {
> >
> > UInt32 processed;
> >
> > @@ -2352,11 +2352,11 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
> > if (p->alignPriceCount >= kAlignTableSize)
> >
> > FillAlignPrices(p);
> >
> > }
> >
> > -
> >
> > +
> >
> > if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
> >
> > break;
> >
> > processed = nowPos32 - startPos32;
> >
> > -
> >
> > +
> >
> > if (maxPackSize)
> >
> > {
> >
> > if (processed + kNumOpts + 300 >= maxUnpackSize
> >
> > @@ -2430,7 +2430,7 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc,
> > p->matchFinderObj = &p->matchFinderBase;
> >
> > MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
> >
> > }
> >
> > -
> >
> > +
> >
> > return SZ_OK;
> >
> > }
> >
> >
> >
> > @@ -2644,7 +2644,7 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
> > return SZ_ERROR_OUTPUT_EOF;
> >
> >
> >
> > res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
> >
> > -
> >
> > +
> >
> > *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
> >
> > *destLen -= outStream.rem;
> >
> > if (outStream.overflow)
> >
> > @@ -2679,7 +2679,7 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
> > }
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > LzmaEnc_Finish(p);
> >
> >
> >
> > /*
> >
> > @@ -2751,7 +2751,7 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte
> > p->rc.outStream = &outStream.vt;
> >
> >
> >
> > res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
> >
> > -
> >
> > +
> >
> > if (res == SZ_OK)
> >
> > {
> >
> > res = LzmaEnc_Encode2(p, progress);
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
> > index 8fd86f224be7..9a29839fe8fe 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
> > @@ -34,9 +34,9 @@ WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE)
> > WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
> >
> > {
> >
> > /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
> >
> > -
> >
> > +
> >
> > #ifdef UNDER_CE
> >
> > -
> >
> > +
> >
> > DWORD threadId;
> >
> > *p = CreateThread(0, 0, func, param, 0, &threadId);
> >
> >
> >
> > @@ -44,7 +44,7 @@ WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
> >
> >
> > unsigned threadId;
> >
> > *p = (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);
> >
> > -
> >
> > +
> >
> > #endif
> >
> >
> >
> > /* maybe we must use errno here, but probably GetLastError() is also OK. */
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
> > index d7426d38a4dd..a8d75ed7095d 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
> > @@ -3,11 +3,11 @@ HISTORY of the LZMA SDK
> >
> >
> > 18.05 2018-04-30
> >
> > -------------------------
> >
> > -- The speed for LZMA/LZMA2 compressing was increased
> >
> > - by 8% for fastest/fast compression levels and
> >
> > +- The speed for LZMA/LZMA2 compressing was increased
> >
> > + by 8% for fastest/fast compression levels and
> >
> > by 3% for normal/maximum compression levels.
> >
> > - Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in
> >
> > - Windows 10 because of some BUG with "Large Pages" in Windows 10.
> >
> > + Windows 10 because of some BUG with "Large Pages" in Windows 10.
> >
> > Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299).
> >
> > - The BUG was fixed in Lzma2Enc.c
> >
> > Lzma2Enc_Encode2() function worked incorretly,
> >
> > @@ -16,7 +16,7 @@ HISTORY of the LZMA SDK
> >
> >
> > 18.03 beta 2018-03-04
> >
> > -------------------------
> >
> > -- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
> >
> > +- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
> >
> > for x64 with about 30% higher speed than main version of LZMA decoder written in C.
> >
> > - The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%.
> >
> > - 7-Zip now can use multi-threading for 7z/LZMA2 decoding,
> >
> > @@ -35,7 +35,7 @@ HISTORY of the LZMA SDK
> > 18.00 beta 2019-01-10
> >
> > -------------------------
> >
> > - The BUG in xz encoder was fixed:
> >
> > - There was memory leak of 16 KB for each file compressed with
> >
> > + There was memory leak of 16 KB for each file compressed with
> >
> > xz compression method, if additional filter was used.
> >
> >
> >
> >
> >
> > @@ -44,7 +44,7 @@ HISTORY of the LZMA SDK
> > - Minor speed optimization for LZMA2 (xz and 7z) multi-threading compression.
> >
> > 7-Zip now uses additional memory buffers for multi-block LZMA2 compression.
> >
> > CPU utilization was slightly improved.
> >
> > -- 7-zip now creates multi-block xz archives by default. Block size can be
> >
> > +- 7-zip now creates multi-block xz archives by default. Block size can be
> >
> > specified with -ms[Size]{m|g} switch.
> >
> > - xz decoder now can unpack random block from multi-block xz archives.
> >
> > - 7-Zip command line: @listfile now doesn't work after -- switch.
> >
> > @@ -55,7 +55,7 @@ HISTORY of the LZMA SDK
> >
> >
> > 17.00 beta 2017-04-29
> >
> > -------------------------
> >
> > -- NewHandler.h / NewHandler.cpp:
> >
> > +- NewHandler.h / NewHandler.cpp:
> >
> > now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900).
> >
> > - C/7zTypes.h : the names of variables in interface structures were changed (vt).
> >
> > - Some bugs were fixed. 7-Zip could crash in some cases.
> >
> > @@ -76,51 +76,51 @@ HISTORY of the LZMA SDK
> > 16.02 2016-05-21
> >
> > -------------------------
> >
> > - The BUG in 16.00 - 16.01 was fixed:
> >
> > - Split Handler (SplitHandler.cpp) returned incorrect
> >
> > + Split Handler (SplitHandler.cpp) returned incorrect
> >
> > total size value (kpidSize) for split archives.
> >
> >
> >
> >
> >
> > 16.01 2016-05-19
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - Some internal changes to reduce the number of compiler warnings.
> >
> >
> >
> >
> >
> > 16.00 2016-05-10
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - Some bugs were fixed.
> >
> >
> >
> >
> >
> > 15.12 2015-11-19
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - The BUG in C version of 7z decoder was fixed:
> >
> > 7zDec.c : SzDecodeLzma2()
> >
> > 7z decoder could mistakenly report about decoding error for some 7z archives
> >
> > that use LZMA2 compression method.
> >
> > - The probability to get that mistaken decoding error report was about
> >
> > - one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
> >
> > + The probability to get that mistaken decoding error report was about
> >
> > + one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
> >
> > - The BUG (in 9.26-15.11) in C version of 7z decoder was fixed:
> >
> > 7zArcIn.c : SzReadHeader2()
> >
> > - 7z decoder worked incorrectly for 7z archives that contain
> >
> > - empty solid blocks, that can be placed to 7z archive, if some file is
> >
> > + 7z decoder worked incorrectly for 7z archives that contain
> >
> > + empty solid blocks, that can be placed to 7z archive, if some file is
> >
> > unavailable for reading during archive creation.
> >
> >
> >
> >
> >
> > 15.09 beta 2015-10-16
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - The BUG in LZMA / LZMA2 encoding code was fixed.
> >
> > The BUG in LzFind.c::MatchFinder_ReadBlock() function.
> >
> > If input data size is larger than (4 GiB - dictionary_size),
> >
> > the following code worked incorrectly:
> >
> > - - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
> >
> > - for compressing from memory to memory.
> >
> > + - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
> >
> > + for compressing from memory to memory.
> >
> > That BUG is not related to LZMA encoder version that works via streams.
> >
> > - - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
> >
> > - default value of chunk size (CLzma2EncProps::blockSize) is changed
> >
> > + - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
> >
> > + default value of chunk size (CLzma2EncProps::blockSize) is changed
> >
> > to value larger than (4 GiB - dictionary_size).
> >
> >
> >
> >
> >
> > 9.38 beta 2015-01-03
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - The BUG in 9.31-9.37 was fixed:
> >
> > IArchiveGetRawProps interface was disabled for 7z archives.
> >
> > - The BUG in 9.26-9.36 was fixed:
> >
> > @@ -128,10 +128,10 @@ HISTORY of the LZMA SDK
> >
> >
> >
> >
> > 9.36 beta 2014-12-26
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - The BUG in command line version was fixed:
> >
> > 7-Zip created temporary archive in current folder during update archive
> >
> > - operation, if -w{Path} switch was not specified.
> >
> > + operation, if -w{Path} switch was not specified.
> >
> > The fixed 7-Zip creates temporary archive in folder that contains updated archive.
> >
> > - The BUG in 9.33-9.35 was fixed:
> >
> > 7-Zip silently ignored file reading errors during 7z or gz archive creation,
> >
> > @@ -140,14 +140,14 @@ HISTORY of the LZMA SDK
> >
> >
> >
> >
> > 9.35 beta 2014-12-07
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - 7zr.exe now support AES encryption.
> >
> > - SFX modules were added to LZMA SDK
> >
> > - Some bugs were fixed.
> >
> >
> >
> >
> >
> > 9.21 beta 2011-04-11
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - New class FString for file names at file systems.
> >
> > - Speed optimization in CRC code for big-endian CPUs.
> >
> > - The BUG in Lzma2Dec.c was fixed:
> >
> > @@ -155,7 +155,7 @@ HISTORY of the LZMA SDK
> >
> >
> >
> >
> > 9.18 beta 2010-11-02
> >
> > --------------------------
> >
> > +-------------------------
> >
> > - New small SFX module for installers (SfxSetup).
> >
> >
> >
> >
> >
> > @@ -168,7 +168,7 @@ HISTORY of the LZMA SDK
> > 9.11 beta 2010-03-15
> >
> > -------------------------
> >
> > - PPMd compression method support
> >
> > -
> >
> > +
> >
> >
> >
> > 9.09 2009-12-12
> >
> > -------------------------
> >
> > @@ -202,7 +202,7 @@ HISTORY of the LZMA SDK
> > 4.61 beta 2008-11-23
> >
> > -------------------------
> >
> > - The bug in ANSI-C LZMA Decoder was fixed:
> >
> > - If encoded stream was corrupted, decoder could access memory
> >
> > + If encoded stream was corrupted, decoder could access memory
> >
> > outside of allocated range.
> >
> > - Some changes in ANSI-C 7z Decoder interfaces.
> >
> > - LZMA SDK is placed in the public domain.
> >
> > @@ -216,7 +216,7 @@ HISTORY of the LZMA SDK
> > 4.59 beta 2008-08-13
> >
> > -------------------------
> >
> > - The bug was fixed:
> >
> > - LZMA Encoder in fast compression mode could access memory outside of
> >
> > + LZMA Encoder in fast compression mode could access memory outside of
> >
> > allocated range in some rare cases.
> >
> >
> >
> >
> >
> > @@ -229,7 +229,7 @@ HISTORY of the LZMA SDK
> >
> >
> > 4.57 2007-12-12
> >
> > -------------------------
> >
> > -- Speed optimizations in ?++ LZMA Decoder.
> >
> > +- Speed optimizations in ?++ LZMA Decoder.
> >
> > - Small changes for more compatibility with some C/C++ compilers.
> >
> >
> >
> >
> >
> > @@ -239,36 +239,36 @@ HISTORY of the LZMA SDK
> > - now it supports BCJ and BCJ2 filters
> >
> > - now it supports files larger than 4 GB.
> >
> > - now it supports "Last Write Time" field for files.
> >
> > -- C++ code for .7z archives compressing/decompressing from 7-zip
> >
> > +- C++ code for .7z archives compressing/decompressing from 7-zip
> >
> > was included to LZMA SDK.
> >
> > -
> >
> > +
> >
> >
> >
> > 4.43 2006-06-04
> >
> > -------------------------
> >
> > - Small changes for more compatibility with some C/C++ compilers.
> >
> > -
> >
> > +
> >
> >
> >
> > 4.42 2006-05-15
> >
> > -------------------------
> >
> > - Small changes in .h files in ANSI-C version.
> >
> > -
> >
> > +
> >
> >
> >
> > 4.39 beta 2006-04-14
> >
> > -------------------------
> >
> > - The bug in versions 4.33b:4.38b was fixed:
> >
> > - C++ version of LZMA encoder could not correctly compress
> >
> > + C++ version of LZMA encoder could not correctly compress
> >
> > files larger than 2 GB with HC4 match finder (-mfhc4).
> >
> > -
> >
> > +
> >
> >
> >
> > 4.37 beta 2005-04-06
> >
> > -------------------------
> >
> > -- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.
> >
> > +- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.
> >
> >
> >
> >
> >
> > 4.35 beta 2005-03-02
> >
> > -------------------------
> >
> > - The bug was fixed in C++ version of LZMA Decoder:
> >
> > - If encoded stream was corrupted, decoder could access memory
> >
> > + If encoded stream was corrupted, decoder could access memory
> >
> > outside of allocated range.
> >
> >
> >
> >
> >
> > @@ -339,7 +339,7 @@ HISTORY of the LZMA SDK
> >
> >
> > 4.17 2005-04-18
> >
> > -------------------------
> >
> > -- New example for RAM->RAM compressing/decompressing:
> >
> > +- New example for RAM->RAM compressing/decompressing:
> >
> > LZMA + BCJ (filter for x86 code):
> >
> > - LzmaRam.h
> >
> > - LzmaRam.cpp
> >
> > @@ -350,11 +350,11 @@ HISTORY of the LZMA SDK
> >
> >
> > 4.16 2005-03-29
> >
> > -------------------------
> >
> > -- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
> >
> > +- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
> >
> > If _LZMA_OUT_READ was defined, and if encoded stream was corrupted,
> >
> > decoder could access memory outside of allocated range.
> >
> > - Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster).
> >
> > - Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
> >
> > + Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
> >
> > LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c
> >
> > - Small speed optimization in LZMA C++ code
> >
> > - filter for SPARC's code was added
> >
> > @@ -369,7 +369,7 @@ HISTORY of the LZMA SDK
> >
> >
> > 4.05 2004-08-25
> >
> > -------------------------
> >
> > -- Source code of filters for x86, IA-64, ARM, ARM-Thumb
> >
> > +- Source code of filters for x86, IA-64, ARM, ARM-Thumb
> >
> > and PowerPC code was included to SDK
> >
> > - Some internal minor changes
> >
> >
> >
> > @@ -381,8 +381,8 @@ HISTORY of the LZMA SDK
> >
> >
> > 4.03 2004-06-18
> >
> > -------------------------
> >
> > -- "Benchmark" command was added. It measures compressing
> >
> > - and decompressing speed and shows rating values.
> >
> > +- "Benchmark" command was added. It measures compressing
> >
> > + and decompressing speed and shows rating values.
> >
> > Also it checks hardware errors.
> >
> >
> >
> >
> >
> > @@ -411,7 +411,7 @@ HISTORY of the LZMA SDK
> >
> >
> > HISTORY of the LZMA
> >
> > -------------------
> >
> > - 2001-2008: Improvements to LZMA compressing/decompressing code,
> >
> > + 2001-2008: Improvements to LZMA compressing/decompressing code,
> >
> > keeping compatibility with original LZMA format
> >
> > 1996-2001: Development of LZMA compression format
> >
> >
> >
> > @@ -419,6 +419,6 @@ HISTORY of the LZMA
> >
> >
> > 2001-08-30: LZMA compression was added to 7-Zip
> >
> > 1999-01-02: First version of 7-Zip was released
> >
> > -
> >
> > +
> >
> >
> >
> > End of document
> >
> > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
> > index a3deb2094335..914bd19e90be 100644
> > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
> > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
> > @@ -2,15 +2,15 @@ LZMA SDK 18.05
> > --------------
> >
> >
> >
> > LZMA SDK provides the documentation, samples, header files,
> >
> > -libraries, and tools you need to develop applications that
> >
> > +libraries, and tools you need to develop applications that
> >
> > use 7z / LZMA / LZMA2 / XZ compression.
> >
> >
> >
> > -LZMA is an improved version of famous LZ77 compression algorithm.
> >
> > +LZMA is an improved version of famous LZ77 compression algorithm.
> >
> > It was improved in way of maximum increasing of compression ratio,
> >
> > -keeping high decompression speed and low memory requirements for
> >
> > +keeping high decompression speed and low memory requirements for
> >
> > decompressing.
> >
> >
> >
> > -LZMA2 is a LZMA based compression method. LZMA2 provides better
> >
> > +LZMA2 is a LZMA based compression method. LZMA2 provides better
> >
> > multithreading support for compression than LZMA and some other improvements.
> >
> >
> >
> > 7z is a file format for data compression and file archiving.
> >
> > @@ -19,7 +19,7 @@ multithreading support for compression than LZMA and some other improvements.
> > 7z also supports AES-256 based encryption.
> >
> >
> >
> > XZ is a file format for data compression that uses LZMA2 compression.
> >
> > -XZ format provides additional features: SHA/CRC check, filters for
> >
> > +XZ format provides additional features: SHA/CRC check, filters for
> >
> > improved compression ratio, splitting to blocks and streams,
> >
> >
> >
> >
> >
> > @@ -33,11 +33,11 @@ Some code in LZMA SDK is based on public domain code from another developers:
> > 1) PPMd var.H (2001): Dmitry Shkarin
> >
> > 2) SHA-256: Wei Dai (Crypto++ library)
> >
> >
> >
> > -Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
> >
> > -original LZMA SDK code, either in source code form or as a compiled binary, for
> >
> > +Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
> >
> > +original LZMA SDK code, either in source code form or as a compiled binary, for
> >
> > any purpose, commercial or non-commercial, and by any means.
> >
> >
> >
> > -LZMA SDK code is compatible with open source licenses, for example, you can
> >
> > +LZMA SDK code is compatible with open source licenses, for example, you can
> >
> > include it to GNU GPL or GNU LGPL code.
> >
> >
> >
> >
> >
> > @@ -60,7 +60,7 @@ LZMA SDK Contents
> > - SFX modules for installers.
> >
> >
> >
> >
> >
> > -UNIX/Linux version
> >
> > +UNIX/Linux version
> >
> > ------------------
> >
> > To compile C++ version of file->file LZMA encoding, go to directory
> >
> > CPP/7zip/Bundles/LzmaCon
> >
> > @@ -68,11 +68,11 @@ and call make to recompile it:
> > make -f makefile.gcc clean all
> >
> >
> >
> > In some UNIX/Linux versions you must compile LZMA with static libraries.
> >
> > -To compile with static libraries, you can use
> >
> > +To compile with static libraries, you can use
> >
> > LIB = -lm -static
> >
> >
> >
> > Also you can use p7zip (port of 7-Zip for POSIX systems like Unix or Linux):
> >
> > -
> >
> > +
> >
> > http://p7zip.sourceforge.net/
> >
> >
> >
> >
> >
> > @@ -120,7 +120,7 @@ C/ - C files (compression / decompression and other)
> > 7z - 7z decoder program (decoding 7z files)
> >
> > Lzma - LZMA program (file->file LZMA encoder/decoder).
> >
> > LzmaLib - LZMA library (.DLL for Windows)
> >
> > - SfxSetup - small SFX module for installers
> >
> > + SfxSetup - small SFX module for installers
> >
> >
> >
> > CPP/ -- CPP files
> >
> >
> >
> > @@ -135,7 +135,7 @@ CPP/ -- CPP files
> > 7z - 7z C++ Encoder/Decoder
> >
> >
> >
> > Bundles - Modules that are bundles of other modules (files)
> >
> > -
> >
> > +
> >
> > Alone7z - 7zr.exe: Standalone 7-Zip console program (reduced version)
> >
> > Format7zExtractR - 7zxr.dll: Reduced version of 7z DLL: extracting from 7z/LZMA/BCJ/BCJ2.
> >
> > Format7zR - 7zr.dll: Reduced version of 7z DLL: extracting/compressing to 7z/LZMA/BCJ/BCJ2
> >
> > @@ -152,7 +152,7 @@ CPP/ -- CPP files
> > Crypto - files for encryption / decompression
> >
> >
> >
> > UI - User Interface files
> >
> > -
> >
> > +
> >
> > Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll
> >
> > Common - Common UI files
> >
> > Console - Code for console program (7z.exe)
> >
> > @@ -178,7 +178,7 @@ Java/ - Java files
> > RangeCoder - Range Coder (special code of compression/decompression)
> >
> >
> >
> >
> >
> > -Note:
> >
> > +Note:
> >
> > Asm / C / C++ source code of LZMA SDK is part of 7-Zip's source code.
> >
> > 7-Zip's source code can be downloaded from 7-Zip's SourceForge page:
> >
> >
> >
> > @@ -190,13 +190,13 @@ LZMA features
> > -------------
> >
> > - Variable dictionary size (up to 1 GB)
> >
> > - Estimated compressing speed: about 2 MB/s on 2 GHz CPU
> >
> > - - Estimated decompressing speed:
> >
> > + - Estimated decompressing speed:
> >
> > - 20-30 MB/s on modern 2 GHz cpu
> >
> > - 1-2 MB/s on 200 MHz simple RISC cpu: (ARM, MIPS, PowerPC)
> >
> > - Small memory requirements for decompressing (16 KB + DictionarySize)
> >
> > - Small code size for decompressing: 5-8 KB
> >
> >
> >
> > -LZMA decoder uses only integer operations and can be
> >
> > +LZMA decoder uses only integer operations and can be
> >
> > implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).
> >
> >
> >
> > Some critical operations that affect the speed of LZMA decompression:
> >
> > @@ -205,7 +205,7 @@ Some critical operations that affect the speed of LZMA decompression:
> > 3) 32-bit shift and arithmetic operations
> >
> >
> >
> > The speed of LZMA decompressing mostly depends from CPU speed.
> >
> > -Memory speed has no big meaning. But if your CPU has small data cache,
> >
> > +Memory speed has no big meaning. But if your CPU has small data cache,
> >
> > overall weight of memory speed will slightly increase.
> >
> >
> >
> >
> >
> > @@ -221,53 +221,53 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]
> >
> >
> > d: decode file
> >
> >
> >
> > - b: Benchmark. There are two tests: compressing and decompressing
> >
> > - with LZMA method. Benchmark shows rating in MIPS (million
> >
> > - instructions per second). Rating value is calculated from
> >
> > + b: Benchmark. There are two tests: compressing and decompressing
> >
> > + with LZMA method. Benchmark shows rating in MIPS (million
> >
> > + instructions per second). Rating value is calculated from
> >
> > measured speed and it is normalized with Intel's Core 2 results.
> >
> > - Also Benchmark checks possible hardware errors (RAM
> >
> > + Also Benchmark checks possible hardware errors (RAM
> >
> > errors in most cases). Benchmark uses these settings:
> >
> > - (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
> >
> > + (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
> >
> > Also you can change the number of iterations. Example for 30 iterations:
> >
> > LZMA b 30
> >
> > Default number of iterations is 10.
> >
> >
> >
> > <Switches>
> >
> > -
> >
> > +
> >
> >
> >
> > -a{N}: set compression mode 0 = fast, 1 = normal
> >
> > default: 1 (normal)
> >
> >
> >
> > d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB)
> >
> > The maximum value for dictionary size is 1 GB = 2^30 bytes.
> >
> > - Dictionary size is calculated as DictionarySize = 2^N bytes.
> >
> > - For decompressing file compressed by LZMA method with dictionary
> >
> > + Dictionary size is calculated as DictionarySize = 2^N bytes.
> >
> > + For decompressing file compressed by LZMA method with dictionary
> >
> > size D = 2^N you need about D bytes of memory (RAM).
> >
> >
> >
> > -fb{N}: set number of fast bytes - [5, 273], default: 128
> >
> > - Usually big number gives a little bit better compression ratio
> >
> > + Usually big number gives a little bit better compression ratio
> >
> > and slower compression process.
> >
> >
> >
> > -lc{N}: set number of literal context bits - [0, 8], default: 3
> >
> > Sometimes lc=4 gives gain for big files.
> >
> >
> >
> > -lp{N}: set number of literal pos bits - [0, 4], default: 0
> >
> > - lp switch is intended for periodical data when period is
> >
> > - equal 2^N. For example, for 32-bit (4 bytes)
> >
> > - periodical data you can use lp=2. Often it's better to set lc0,
> >
> > + lp switch is intended for periodical data when period is
> >
> > + equal 2^N. For example, for 32-bit (4 bytes)
> >
> > + periodical data you can use lp=2. Often it's better to set lc0,
> >
> > if you change lp switch.
> >
> >
> >
> > -pb{N}: set number of pos bits - [0, 4], default: 2
> >
> > - pb switch is intended for periodical data
> >
> > + pb switch is intended for periodical data
> >
> > when period is equal 2^N.
> >
> >
> >
> > - -mf{MF_ID}: set Match Finder. Default: bt4.
> >
> > - Algorithms from hc* group doesn't provide good compression
> >
> > - ratio, but they often works pretty fast in combination with
> >
> > + -mf{MF_ID}: set Match Finder. Default: bt4.
> >
> > + Algorithms from hc* group doesn't provide good compression
> >
> > + ratio, but they often works pretty fast in combination with
> >
> > fast mode (-a0).
> >
> >
> >
> > - Memory requirements depend from dictionary size
> >
> > - (parameter "d" in table below).
> >
> > + Memory requirements depend from dictionary size
> >
> > + (parameter "d" in table below).
> >
> >
> >
> > MF_ID Memory Description
> >
> >
> >
> > @@ -276,8 +276,8 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]
> > bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing.
> >
> > hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing.
> >
> >
> >
> > - -eos: write End Of Stream marker. By default LZMA doesn't write
> >
> > - eos marker, since LZMA decoder knows uncompressed size
> >
> > + -eos: write End Of Stream marker. By default LZMA doesn't write
> >
> > + eos marker, since LZMA decoder knows uncompressed size
> >
> > stored in .lzma file header.
> >
> >
> >
> > -si: Read data from stdin (it will write End Of Stream marker).
> >
> > @@ -286,16 +286,16 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]
> >
> >
> > Examples:
> >
> >
> >
> > -1) LZMA e file.bin file.lzma -d16 -lc0
> >
> > +1) LZMA e file.bin file.lzma -d16 -lc0
> >
> >
> >
> > -compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
> >
> > -and 0 literal context bits. -lc0 allows to reduce memory requirements
> >
> > +compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
> >
> > +and 0 literal context bits. -lc0 allows to reduce memory requirements
> >
> > for decompression.
> >
> >
> >
> >
> >
> > 2) LZMA e file.bin file.lzma -lc0 -lp2
> >
> >
> >
> > -compresses file.bin to file.lzma with settings suitable
> >
> > +compresses file.bin to file.lzma with settings suitable
> >
> > for 32-bit periodical data (for example, ARM or MIPS code).
> >
> >
> >
> > 3) LZMA d file.lzma file.bin
> >
> > @@ -309,9 +309,9 @@ Compression ratio hints
> > Recommendations
> >
> > ---------------
> >
> >
> >
> > -To increase the compression ratio for LZMA compressing it's desirable
> >
> > +To increase the compression ratio for LZMA compressing it's desirable
> >
> > to have aligned data (if it's possible) and also it's desirable to locate
> >
> > -data in such order, where code is grouped in one place and data is
> >
> > +data in such order, where code is grouped in one place and data is
> >
> > grouped in other place (it's better than such mixing: code, data, code,
> >
> > data, ...).
> >
> >
> >
> > @@ -319,19 +319,19 @@ data, ...).
> > Filters
> >
> > -------
> >
> > You can increase the compression ratio for some data types, using
> >
> > -special filters before compressing. For example, it's possible to
> >
> > -increase the compression ratio on 5-10% for code for those CPU ISAs:
> >
> > +special filters before compressing. For example, it's possible to
> >
> > +increase the compression ratio on 5-10% for code for those CPU ISAs:
> >
> > x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.
> >
> >
> >
> > You can find C source code of such filters in C/Bra*.* files
> >
> >
> >
> > -You can check the compression ratio gain of these filters with such
> >
> > +You can check the compression ratio gain of these filters with such
> >
> > 7-Zip commands (example for ARM code):
> >
> > No filter:
> >
> > 7z a a1.7z a.bin -m0=lzma
> >
> >
> >
> > With filter for little-endian ARM code:
> >
> > - 7z a a2.7z a.bin -m0=arm -m1=lzma
> >
> > + 7z a a2.7z a.bin -m0=arm -m1=lzma
> >
> >
> >
> > It works in such manner:
> >
> > Compressing = Filter_encoding + LZMA_encoding
> >
> > @@ -339,11 +339,11 @@ Decompressing = LZMA_decoding + Filter_decoding
> >
> >
> > Compressing and decompressing speed of such filters is very high,
> >
> > so it will not increase decompressing time too much.
> >
> > -Moreover, it reduces decompression time for LZMA_decoding,
> >
> > +Moreover, it reduces decompression time for LZMA_decoding,
> >
> > since compression ratio with filtering is higher.
> >
> >
> >
> > -These filters convert CALL (calling procedure) instructions
> >
> > -from relative offsets to absolute addresses, so such data becomes more
> >
> > +These filters convert CALL (calling procedure) instructions
> >
> > +from relative offsets to absolute addresses, so such data becomes more
> >
> > compressible.
> >
> >
> >
> > For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
> >
> > diff --git a/BaseTools/Source/C/Makefiles/app.makefile b/BaseTools/Source/C/Makefiles/app.makefile
> > index fcadb4ed2194..6a2a8f5e8a0e 100644
> > --- a/BaseTools/Source/C/Makefiles/app.makefile
> > +++ b/BaseTools/Source/C/Makefiles/app.makefile
> > @@ -12,9 +12,9 @@ include $(MAKEROOT)/Makefiles/header.makefile
> > APPLICATION = $(MAKEROOT)/bin/$(APPNAME)
> >
> >
> >
> > .PHONY:all
> >
> > -all: $(MAKEROOT)/bin $(APPLICATION)
> >
> > +all: $(MAKEROOT)/bin $(APPLICATION)
> >
> >
> >
> > -$(APPLICATION): $(OBJECTS)
> >
> > +$(APPLICATION): $(OBJECTS)
> >
> > $(LINKER) -o $(APPLICATION) $(BUILD_LFLAGS) $(OBJECTS) -L$(MAKEROOT)/libs $(LIBS)
> >
> >
> >
> > $(OBJECTS): $(MAKEROOT)/Include/Common/BuildVersion.h
> >
> > diff --git a/BaseTools/Source/C/Makefiles/footer.makefile b/BaseTools/Source/C/Makefiles/footer.makefile
> > index e823246cfbb4..85c3374224f2 100644
> > --- a/BaseTools/Source/C/Makefiles/footer.makefile
> > +++ b/BaseTools/Source/C/Makefiles/footer.makefile
> > @@ -14,10 +14,10 @@ $(MAKEROOT)/libs-$(HOST_ARCH):
> > install: $(MAKEROOT)/libs-$(HOST_ARCH) $(LIBRARY)
> >
> > cp $(LIBRARY) $(MAKEROOT)/libs-$(HOST_ARCH)
> >
> >
> >
> > -$(LIBRARY): $(OBJECTS)
> >
> > +$(LIBRARY): $(OBJECTS)
> >
> > $(BUILD_AR) crs $@ $^
> >
> >
> >
> > -%.o : %.c
> >
> > +%.o : %.c
> >
> > $(BUILD_CC) -c $(BUILD_CPPFLAGS) $(BUILD_CFLAGS) $< -o $@
> >
> >
> >
> > %.o : %.cpp
> >
> > diff --git a/BaseTools/Source/C/Makefiles/header.makefile b/BaseTools/Source/C/Makefiles/header.makefile
> > index 52cbffcb4423..4e9b36d98bdb 100644
> > --- a/BaseTools/Source/C/Makefiles/header.makefile
> > +++ b/BaseTools/Source/C/Makefiles/header.makefile
> > @@ -61,7 +61,7 @@ else
> > $(error Bad HOST_ARCH)
> >
> > endif
> >
> >
> >
> > -INCLUDE = $(TOOL_INCLUDE) -I $(MAKEROOT) -I $(MAKEROOT)/Include/Common -I $(MAKEROOT)/Include/ -I
> > $(MAKEROOT)/Include/IndustryStandard -I $(MAKEROOT)/Common/ -I .. -I . $(ARCH_INCLUDE)
> >
> > +INCLUDE = $(TOOL_INCLUDE) -I $(MAKEROOT) -I $(MAKEROOT)/Include/Common -I $(MAKEROOT)/Include/ -I
> > $(MAKEROOT)/Include/IndustryStandard -I $(MAKEROOT)/Common/ -I .. -I . $(ARCH_INCLUDE)
> >
> > BUILD_CPPFLAGS = $(INCLUDE)
> >
> >
> >
> > # keep EXTRA_OPTFLAGS last
> >
> > @@ -82,7 +82,7 @@ BUILD_CXXFLAGS = -Wno-unused-result
> >
> >
> > ifeq ($(HOST_ARCH), IA32)
> >
> > #
> >
> > -# Snow Leopard is a 32-bit and 64-bit environment. uname -m returns i386, but gcc defaults
> >
> > +# Snow Leopard is a 32-bit and 64-bit environment. uname -m returns i386, but gcc defaults
> >
> > # to x86_64. So make sure tools match uname -m. You can manual have a 64-bit kernal on Snow Leopard
> >
> > # so only do this is uname -m returns i386.
> >
> > #
> >
> > @@ -96,7 +96,7 @@ endif
> > # keep BUILD_OPTFLAGS last
> >
> > BUILD_CFLAGS += $(BUILD_OPTFLAGS)
> >
> > BUILD_CXXFLAGS += $(BUILD_OPTFLAGS)
> >
> > -
> >
> > +
> >
> > # keep EXTRA_LDFLAGS last
> >
> > BUILD_LFLAGS += $(EXTRA_LDFLAGS)
> >
> >
> >
> > @@ -107,7 +107,7 @@ BUILD_LFLAGS += $(EXTRA_LDFLAGS)
> > all:
> >
> >
> >
> > $(MAKEROOT)/libs:
> >
> > - mkdir $(MAKEROOT)/libs
> >
> > + mkdir $(MAKEROOT)/libs
> >
> >
> >
> > $(MAKEROOT)/bin:
> >
> > mkdir $(MAKEROOT)/bin
> >
> > diff --git a/BaseTools/Source/C/Makefiles/lib.makefile b/BaseTools/Source/C/Makefiles/lib.makefile
> > index a9965fc628d9..2577c15380a9 100644
> > --- a/BaseTools/Source/C/Makefiles/lib.makefile
> > +++ b/BaseTools/Source/C/Makefiles/lib.makefile
> > @@ -9,6 +9,6 @@ include $(MAKEROOT)/Makefiles/header.makefile
> >
> >
> > LIBRARY = $(MAKEROOT)/libs/lib$(LIBNAME).a
> >
> >
> >
> > -all: $(MAKEROOT)/libs $(LIBRARY)
> >
> > +all: $(MAKEROOT)/libs $(LIBRARY)
> >
> >
> >
> > include $(MAKEROOT)/Makefiles/footer.makefile
> >
> > diff --git a/BaseTools/Source/C/Makefiles/ms.common b/BaseTools/Source/C/Makefiles/ms.common
> > index 75c9bb43a32c..f5f77fdc0bc5 100644
> > --- a/BaseTools/Source/C/Makefiles/ms.common
> > +++ b/BaseTools/Source/C/Makefiles/ms.common
> > @@ -57,6 +57,6 @@ LINKER = $(LD)
> >
> >
> > INC = -I . -I $(SOURCE_PATH)\Include -I $(ARCH_INCLUDE) -I $(SOURCE_PATH)\Common $(INC)
> >
> >
> >
> > -CFLAGS = $(CFLAGS) /nologo /Zi /c /O2 /MT /W4 /WX /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
> >
> > -CPPFLAGS = $(CPPFLAGS) /EHsc /nologo /Zi /c /O2 /MT /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
> >
> > +CFLAGS = $(CFLAGS) /nologo /Zi /c /O2 /MT /W4 /WX /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
> >
> > +CPPFLAGS = $(CPPFLAGS) /EHsc /nologo /Zi /c /O2 /MT /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/GNUmakefile b/BaseTools/Source/C/VfrCompile/GNUmakefile
> > index 8b94c73bbefa..42e3d7da020f 100644
> > --- a/BaseTools/Source/C/VfrCompile/GNUmakefile
> > +++ b/BaseTools/Source/C/VfrCompile/GNUmakefile
> > @@ -36,9 +36,9 @@ include $(MAKEROOT)/Makefiles/header.makefile
> > APPLICATION = $(MAKEROOT)/bin/$(APPNAME)
> >
> >
> >
> > .PHONY:all
> >
> > -all: $(MAKEROOT)/bin $(APPLICATION)
> >
> > +all: $(MAKEROOT)/bin $(APPLICATION)
> >
> >
> >
> > -$(APPLICATION): $(OBJECTS)
> >
> > +$(APPLICATION): $(OBJECTS)
> >
> > $(LINKER) -o $(APPLICATION) $(VFR_LFLAGS) $(OBJECTS) -L$(MAKEROOT)/libs $(LIBS)
> >
> >
> >
> > VfrCompiler.o: ../Include/Common/BuildVersion.h
> >
> > @@ -68,7 +68,7 @@ AParser.o: Pccts/h/AParser.cpp
> >
> >
> > VfrSyntax.o: VfrSyntax.cpp
> >
> > $(BUILD_CXX) -c $(VFR_CPPFLAGS) $(INC) $(VFR_CXXFLAGS) $? -o $@
> >
> > -
> >
> > +
> >
> > clean: localClean
> >
> >
> >
> > localClean:
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
> > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
> > index 500d84f2e890..5ca0915a141b 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
> > @@ -489,7 +489,7 @@ o Cleaned up the dup() stuff in AST hierarchy to use shallowCopy() to
> > {
> >
> > return new AST(*this);
> >
> > }
> >
> > -
> >
> > +
> >
> > if you have defined a copy constructor such as
> >
> >
> >
> > AST(const AST &t) // shallow copy constructor
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
> > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
> > index 4d84d1c19cfe..3f9f7a676697 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
> > @@ -17,53 +17,53 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Note: Items #153 to #1 are now in a separate file named
> >
> > CHANGES_FROM_133_BEFORE_MR13.txt
> >
> > -------------------------------------------------------
> >
> > -
> >
> > +
> >
> > #312. (Changed in MR33) Bug caused by change #299.
> >
> >
> >
> > In change #299 a warning message was suppressed when there was
> >
> > - no LT(1) in a semantic predicate and max(k,ck) was 1. The
> >
> > + no LT(1) in a semantic predicate and max(k,ck) was 1. The
> >
> > changed caused the code which set a default predicate depth for
> >
> > the semantic predicate to be left as 0 rather than set to 1.
> >
> > -
> >
> > +
> >
> > This manifested as an error at line #1559 of mrhost.c
> >
> > -
> >
> > +
> >
> > Reported by Peter Dulimov.
> >
> > -
> >
> > +
> >
> > #311. (Changed in MR33) Added sorcer/lib to Makefile.
> >
> >
> >
> > Reported by Dale Martin.
> >
> > -
> >
> > +
> >
> > #310. (Changed in MR32) In C mode zzastPush was spelled zzastpush in one case.
> >
> >
> >
> > Reported by Jean-Claude Durand
> >
> > -
> >
> > +
> >
> > #309. (Changed in MR32) Renamed baseName because of VMS name conflict
> >
> >
> >
> > Renamed baseName to pcctsBaseName to avoid library name conflict with
> >
> > VMS library routine. Reported by Jean-Fran�ois PI�RONNE.
> >
> > -
> >
> > +
> >
> > #308. (Changed in MR32) Used "template" as name of formal in C routine
> >
> >
> >
> > In astlib.h routine ast_scan a formal was named "template". This caused
> >
> > problems when the C code was compiled with a C++ compiler. Reported by
> >
> > Sabyasachi Dey.
> >
> > -
> >
> > +
> >
> > #307. (Changed in MR31) Compiler dependent bug in function prototype generation
> >
> > -
> >
> > +
> >
> > The code which generated function prototypes contained a bug which
> >
> > was compiler/optimization dependent. Under some circumstance an
> >
> > extra character would be included in portions of a function prototype.
> >
> > -
> >
> > +
> >
> > Reported by David Cook.
> >
> > -
> >
> > +
> >
> > #306. (Changed in MR30) Validating predicate following a token
> >
> >
> >
> > - A validating predicate which immediately followed a token match
> >
> > + A validating predicate which immediately followed a token match
> >
> > consumed the token after the predicate rather than before. Prior
> >
> > to this fix (in the following example) isValidTimeScaleValue() in
> >
> > the predicate would test the text for TIMESCALE rather than for
> >
> > NUMBER:
> >
> > -
> >
> > +
> >
> > time_scale :
> >
> > TIMESCALE
> >
> > <<isValidTimeScaleValue(LT(1)->getText())>>?
> >
> > @@ -71,23 +71,23 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > ( us:MICROSECOND << tVal = ...>>
> >
> > | ns:NANOSECOND << tVal = ... >>
> >
> > )
> >
> > -
> >
> > +
> >
> > Reported by Adalbert Perbandt.
> >
> > -
> >
> > +
> >
> > #305. (Changed in MR30) Alternatives with guess blocks inside (...)* blocks.
> >
> >
> >
> > In MR14 change #175 fixed a bug in the prediction expressions for guess
> >
> > blocks which were of the form (alpha)? beta. Unfortunately, this
> >
> > resulted in a new bug as exemplified by the example below, which computed
> >
> > the first set for r as {B} rather than {B C}:
> >
> > -
> >
> > +
> >
> > r : ( (A)? B
> >
> > | C
> >
> > )*
> >
> > -
> >
> > +
> >
> > This example doesn't make any sense as A is not a prefix of B, but it
> >
> > illustrates the problem. This bug did not appear for:
> >
> > -
> >
> > +
> >
> > r : ( (A)?
> >
> > | C
> >
> > )*
> >
> > @@ -98,29 +98,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > constructs which appear to have identical ambiguities (between repeating
> >
> > the loop vs. exiting the loop). MR30 retains this fix, but the implementation
> >
> > is slightly different.
> >
> > -
> >
> > +
> >
> > r_star : ( (A B)? )* A ;
> >
> > r_plus : ( (A B)? )+ A ;
> >
> >
> >
> > Reported by Arpad Beszedes (beszedes inf.u-szeged.hu).
> >
> > -
> >
> > +
> >
> > #304. (Changed in MR30) Crash when mismatch between output value counts.
> >
> >
> >
> > For a rule such as:
> >
> > -
> >
> > +
> >
> > r1 : r2>[i,j];
> >
> > r2 >[int i, int j] : A;
> >
> > -
> >
> > +
> >
> > If there were extra actuals for the reference to rule r2 from rule r1
> >
> > there antlr would crash. This bug was introduced by change #276.
> >
> >
> >
> > Reported by Sinan Karasu.
> >
> > -
> >
> > +
> >
> > #303. (Changed in MR30) DLGLexerBase::replchar
> >
> >
> >
> > - DLGLexerBase::replchar and the C mode routine zzreplchar did not work
> >
> > + DLGLexerBase::replchar and the C mode routine zzreplchar did not work
> >
> > properly when the new character was 0.
> >
> > -
> >
> > +
> >
> > Reported with fix by Philippe Laporte
> >
> >
> >
> > #302. (Changed in MR28) Fix significant problems in initial release of MR27.
> >
> > @@ -129,29 +129,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > To have antlr generate true tabs rather than spaces, use "antlr -tab 0".
> >
> > To generate 4 spaces per tab stop use "antlr -tab 4"
> >
> > -
> >
> > +
> >
> > #300. (Changed in MR27)
> >
> >
> >
> > Consider the following methods of constructing an AST from ID:
> >
> > -
> >
> > +
> >
> > rule1!
> >
> > : id:ID << #0 = #[id]; >> ;
> >
> > -
> >
> > +
> >
> > rule2!
> >
> > : id:ID << #0 = #id; >> ;
> >
> > -
> >
> > +
> >
> > rule3
> >
> > : ID ;
> >
> > -
> >
> > +
> >
> > rule4
> >
> > : id:ID << #0 = #id; >> ;
> >
> > -
> >
> > +
> >
> > For rule_2, the AST corresponding to id would always be NULL. This
> >
> > is because the user explicitly suppressed AST construction using the
> >
> > "!" operator on the rule. In MR27 the use of an AST expression
> >
> > such as #id overrides the "!" operator and forces construction of
> >
> > the AST.
> >
> > -
> >
> > +
> >
> > This fix does not apply to C mode ASTs when the ASTs are referenced
> >
> > using numbers rather than symbols.
> >
> >
> >
> > @@ -167,28 +167,28 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > then pccts doesn't know how many lookahead tokens to use for context.
> >
> > However, if max(k,ck) is 1 then there is really only one choice and
> >
> > the warning is unnecessary.
> >
> > -
> >
> > +
> >
> > #298. (Changed in MR27) Removed "register" for lastpos in dlgauto.c zzgettok
> >
> >
> >
> > #297. (Changed in MR27) Incorrect prototypes when used with classic C
> >
> >
> >
> > There were a number of errors in function headers when antlr was
> >
> > built with compilers that do not have __STDC__ or __cplusplus set.
> >
> > -
> >
> > +
> >
> > The functions which have variable length argument lists now use
> >
> > PCCTS_USE_STDARG rather than __USE_PROTOTYPES__ to determine
> >
> > whether to use stdargs or varargs.
> >
> >
> >
> > #296. (Changed in MR27) Complex return types in rules.
> >
> >
> >
> > - The following return type was not properly handled when
> >
> > + The following return type was not properly handled when
> >
> > unpacking a struct with containing multiple return values:
> >
> > -
> >
> > - rule > [int i, IIR_Bool (IIR_Decl::*constraint)()] : ...
> >
> > +
> >
> > + rule > [int i, IIR_Bool (IIR_Decl::*constraint)()] : ...
> >
> >
> >
> > Instead of using "constraint", the program got lost and used
> >
> > an empty string.
> >
> > -
> >
> > +
> >
> > Reported by P.A. Wilsey.
> >
> >
> >
> > #295. (Changed in MR27) Extra ";" following zzGUESS_DONE sometimes.
> >
> > @@ -197,15 +197,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > preceding the "else" clause of an "if".
> >
> >
> >
> > Reported by P.A. Wilsey.
> >
> > -
> >
> > +
> >
> > #294. (Changed in MR27) Infinite loop in antlr for nested blocks
> >
> >
> >
> > An oversight in detecting an empty alternative sometimes led
> >
> > to an infinite loop in antlr when it encountered a rule with
> >
> > nested blocks and guess blocks.
> >
> > -
> >
> > +
> >
> > Reported by P.A. Wilsey.
> >
> > -
> >
> > +
> >
> > #293. (Changed in MR27) Sorcerer optimization of _t->type()
> >
> >
> >
> > Sorcerer generated code may contain many calls to _t->type() in a
> >
> > @@ -224,21 +224,21 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > Fix to serious code generation error in MR23 for (...)+ block.
> >
> >
> >
> > -#290. (Changed in MR23)
> >
> > +#290. (Changed in MR23)
> >
> >
> >
> > Item #247 describes a change in the way {...} blocks handled
> >
> > an error. Consider:
> >
> >
> >
> > r1 : {A} b ;
> >
> > b : B;
> >
> > -
> >
> > +
> >
> > with input "C".
> >
> >
> >
> > Prior to change #247, the error would resemble "expected B -
> >
> > found C". This is correct but incomplete, and therefore
> >
> > misleading. In #247 it was changed to "expected A, B - found
> >
> > C". This was fine, except for users of parser exception
> >
> > - handling because the exception was generated in the epilogue
> >
> > + handling because the exception was generated in the epilogue
> >
> > for {...} block rather than in rule b. This made it difficult
> >
> > for users of parser exception handling because B was not
> >
> > expected in that context. Those not using parser exception
> >
> > @@ -252,7 +252,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > an empty production and it is the last alternative of a sub-block.
> >
> > In contrast, (something | epsilon | something) should generate the
> >
> > same code as before, even when exceptions are used.
> >
> > -
> >
> > +
> >
> > Reported by Philippe Laporte (philippe at transvirtual.com).
> >
> >
> >
> > #289. (Changed in MR23) Bug in matching complement of a #tokclass
> >
> > @@ -261,43 +261,43 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > and uncomplemented form, the bit set generated for its first use was used
> >
> > for both cases. However, the prediction expression was correctly computed
> >
> > in both cases. This meant that the second case would never be matched
> >
> > - because, for the second appearance, the prediction expression and the
> >
> > + because, for the second appearance, the prediction expression and the
> >
> > set to be matched would be complements of each other.
> >
> > -
> >
> > +
> >
> > Consider:
> >
> > -
> >
> > +
> >
> > #token A "a"
> >
> > #token B "b"
> >
> > #token C "c"
> >
> > #tokclass AB {A B}
> >
> > -
> >
> > +
> >
> > r1 : AB /* alt 1x */
> >
> > | ~AB /* alt 1y */
> >
> > ;
> >
> > -
> >
> > +
> >
> > Prior to MR23, this resulted in alternative 1y being unreachable. Had it
> >
> > been written:
> >
> > -
> >
> > +
> >
> > r2 : ~AB /* alt 2x */
> >
> > : AB /* alt 2y */
> >
> > -
> >
> > - then alternative 2y would have become unreachable.
> >
> > -
> >
> > +
> >
> > + then alternative 2y would have become unreachable.
> >
> > +
> >
> > This bug was only for the case of complemented #tokclass. For complemented
> >
> > - #token the proper code was generated.
> >
> > -
> >
> > + #token the proper code was generated.
> >
> > +
> >
> > #288. (Changed in MR23) #errclass not restricted to choice points
> >
> >
> >
> > The #errclass directive is supposed to allow a programmer to define
> >
> > print strings which should appear in syntax error messages as a replacement
> >
> > for some combinations of tokens. For instance:
> >
> > -
> >
> > +
> >
> > #errclass Operator {PLUS MINUS TIMES DIVIDE}
> >
> > -
> >
> > +
> >
> > If a syntax message includes all four of these tokens, and there is no
> >
> > "better" choice of error class, the word "Operator" will be used rather
> >
> > than a list of the four token names.
> >
> > -
> >
> > +
> >
> > Prior to MR23 the #errclass definitions were used only at choice points
> >
> > (which call the FAIL macro). In other cases where there was no choice
> >
> > (e.g. where a single token or token class were matched) the #errclass
> >
> > @@ -307,7 +307,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > when matching a #tokclass, a wildcard (i.e. "*"), or the complement of a
> >
> > #token or #tokclass (e.g. ~Operator).
> >
> >
> >
> > - Please note that #errclass may now be defined using #tokclass names
> >
> > + Please note that #errclass may now be defined using #tokclass names
> >
> > (see Item #284).
> >
> >
> >
> > Reported by Philip A. Wilsey.
> >
> > @@ -317,25 +317,25 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Item #148 describes how to give a print name to a #token so that,for
> >
> > example, #token ID could have the expression "identifier" in syntax
> >
> > error messages. This has been extended to #tokclass:
> >
> > -
> >
> > +
> >
> > #token ID("identifier") "[a-zA-Z]+"
> >
> > - #tokclass Primitive("primitive type")
> >
> > - {INT, FLOAT, CHAR, FLOAT, DOUBLE, BOOL}
> >
> > + #tokclass Primitive("primitive type")
> >
> > + {INT, FLOAT, CHAR, FLOAT, DOUBLE, BOOL}
> >
> >
> >
> > This is really a cosmetic change, since #tokclass names do not appear
> >
> > in any error messages.
> >
> > -
> >
> > +
> >
> > #286. (Changed in MR23) Makefile change to use of cd
> >
> >
> >
> > In cases where a pccts subdirectory name matched a directory identified
> >
> > in a $CDPATH environment variable the build would fail. All makefile
> >
> > cd commands have been changed from "cd xyz" to "cd ./xyz" in order
> >
> > to avoid this problem.
> >
> > -
> >
> > +
> >
> > #285. (Changed in MR23) Check for null pointers in some dlg structures
> >
> >
> >
> > An invalid regular expression can cause dlg to build an invalid
> >
> > - structure to represent the regular expression even while it issues
> >
> > + structure to represent the regular expression even while it issues
> >
> > error messages. Additional pointer checks were added.
> >
> >
> >
> > Reported by Robert Sherry.
> >
> > @@ -354,7 +354,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > Problem reported by Mike Dimmick (mike dimmick.demon.co.uk).
> >
> >
> >
> > -#283. (Changed in MR23) Option -tmake invoke's parser's tmake
> >
> > +#283. (Changed in MR23) Option -tmake invoke's parser's tmake
> >
> >
> >
> > When the string #(...) appears in an action antlr replaces it with
> >
> > a call to ASTBase::tmake(...) to construct an AST. It is sometimes
> >
> > @@ -364,15 +364,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > The antlr option -tmake replaces the call to ASTBase::tmake with a call
> >
> > to a user supplied tmake routine.
> >
> > -
> >
> > +
> >
> > #282. (Changed in MR23) Initialization error for DBG_REFCOUNTTOKEN
> >
> >
> >
> > - When the pre-processor symbol DBG_REFCOUNTTOKEN is defined
> >
> > + When the pre-processor symbol DBG_REFCOUNTTOKEN is defined
> >
> > incorrect code is generated to initialize ANTLRRefCountToken::ctor and
> >
> > dtor.
> >
> >
> >
> > Fix reported by Sven Kuehn (sven sevenkuehn.de).
> >
> > -
> >
> > +
> >
> > #281. (Changed in MR23) Addition of -noctor option for Sorcerer
> >
> >
> >
> > Added a -noctor option to suppress generation of the blank ctor
> >
> > @@ -395,29 +395,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > alternatives which caused problems when there was a block contained
> >
> > in an alternative. For instance, in the following rule;
> >
> >
> >
> > - statement : IF S { ELSE S }
> >
> > + statement : IF S { ELSE S }
> >
> > exception ....
> >
> > ;
> >
> >
> >
> > - the exception would be attached to the {...} block instead of the
> >
> > + the exception would be attached to the {...} block instead of the
> >
> > entire alternative because it was attached, in error, to the last
> >
> > alternative instead of the last OPEN alternative.
> >
> >
> >
> > Reported by Ty Mordane (tymordane hotmail.com).
> >
> > -
> >
> > +
> >
> > #278. (Changed in MR23) makefile changes
> >
> >
> >
> > Contributed by Tomasz Babczynski (faster lab05-7.ict.pwr.wroc.pl).
> >
> >
> >
> > The -cfile option is not absolutely needed: when extension of
> >
> > - source file is one of the well-known C/C++ extensions it is
> >
> > + source file is one of the well-known C/C++ extensions it is
> >
> > treated as C/C++ source
> >
> >
> >
> > The gnu make defines the CXX variable as the default C++ compiler
> >
> > name, so I added a line to copy this (if defined) to the CCC var.
> >
> >
> >
> > Added a -sor option: after it any -class command defines the class
> >
> > - name for sorcerer, not for ANTLR. A file extended with .sor is
> >
> > + name for sorcerer, not for ANTLR. A file extended with .sor is
> >
> > treated as sorcerer input. Because sorcerer can be called multiple
> >
> > times, -sor option can be repeated. Any files and classes (one class
> >
> > per group) after each -sor makes one tree parser.
> >
> > @@ -448,7 +448,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > rule : <<my_predicate>>? [my_fail_action] A
> >
> > | ...
> >
> >
> >
> > -
> >
> > +
> >
> > the code for my_fail_action would have to contain logic for handling
> >
> > the guess part of the zzfailed_pred macro. The user should not have
> >
> > to be aware of the guess logic in writing the fail action.
> >
> > @@ -501,7 +501,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Foo _retv = expr;
> >
> > ...
> >
> > }
> >
> > -
> >
> > +
> >
> > A rule with more than one return argument:
> >
> >
> >
> > r2 > [Foo f = expr1, Bar b = expr2 ] :
> >
> > @@ -567,13 +567,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > Multi-threaded DLL
> >
> > Debug Multi-threaded DLL
> >
> > -
> >
> > - Suggested by Bill Menees (bill.menees gogallagher.com)
> >
> > -
> >
> > +
> >
> > + Suggested by Bill Menees (bill.menees gogallagher.com)
> >
> > +
> >
> > #272. (Changed in MR23) Failed semantic predicate reported via virtual function
> >
> >
> >
> > In the past, a failed semantic predicated reported the problem via a
> >
> > - macro which used fprintf(). The macro now expands into a call on
> >
> > + macro which used fprintf(). The macro now expands into a call on
> >
> > the virtual function ANTLRParser::failedSemanticPredicate().
> >
> >
> >
> > #271. (Changed in MR23) Warning for LT(i), LATEXT(i) in token match actions
> >
> > @@ -594,7 +594,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > This behavior should be changed, but it appears in too many programs
> >
> > now. Another problem, perhaps more significant, is that the obvious
> >
> > - fix (moving the consume() call to before the action) could change the
> >
> > + fix (moving the consume() call to before the action) could change the
> >
> > order in which input is requested and output appears in existing programs.
> >
> >
> >
> > This problem was reported, along with a fix by Benjamin Mandel
> >
> > @@ -610,7 +610,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > The output from dlg contains a construct similar to the
> >
> > following:
> >
> > -
> >
> > +
> >
> > struct XXX {
> >
> > static const int size;
> >
> > static int array1[5];
> >
> > @@ -619,7 +619,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > const int XXX::size = 4;
> >
> > int XXX::array1[size+1];
> >
> >
> >
> > -
> >
> > +
> >
> > The problem is that although the expression "size+1" used in
> >
> > the definition of array1 is equal to 5 (the expression used to
> >
> > declare array), it is not considered equivalent by some compilers.
> >
> > @@ -634,10 +634,10 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > appropriate one. The appropriate one is computed by comparing
> >
> > the token codes of lookahead token i (for i = 1 to k) with
> >
> > the FIRST(i) set.
> >
> > -
> >
> > +
> >
> > This has been corrected in ANTLRParser::syn().
> >
> >
> >
> > - Reported by Bill Menees (bill.menees gogallagher.com)
> >
> > + Reported by Bill Menees (bill.menees gogallagher.com)
> >
> >
> >
> > #267. (Changed in MR23) AST traversal functions client data argument
> >
> >
> >
> > @@ -651,8 +651,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > **** Warning: this changes the AST signature. ***
> >
> > **** Be sure to revise your AST functions of the same name ***
> >
> >
> >
> > - Bill Menees (bill.menees gogallagher.com)
> >
> > -
> >
> > + Bill Menees (bill.menees gogallagher.com)
> >
> > +
> >
> > #266. (Changed in MR23) virtual function printMessage()
> >
> >
> >
> > Bill Menees (bill.menees gogallagher.com) has completed the
> >
> > @@ -669,7 +669,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > In C++ mode labase++ is called when a token is matched.
> >
> > It appears that labase is not used in C++ mode at all, so
> >
> > this code has been commented out.
> >
> > -
> >
> > +
> >
> > #264. (Changed in MR23) Complete rewrite of ParserBlackBox.h
> >
> >
> >
> > The parser black box (PBlackBox.h) was completely rewritten
> >
> > @@ -694,7 +694,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > #260. (MR22) Raise default lex buffer size from 8,000 to 32,000 bytes.
> >
> >
> >
> > - ZZLEXBUFSIZE is the size (in bytes) of the buffer used by dlg
> >
> > + ZZLEXBUFSIZE is the size (in bytes) of the buffer used by dlg
> >
> > generated lexers. The default value has been raised to 32,000 and
> >
> > the value used by antlr, dlg, and sorcerer has also been raised to
> >
> > 32,000.
> >
> > @@ -759,12 +759,12 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > #256. (MR21a) Malformed syntax graph causes crash after error message.
> >
> >
> >
> > In the past, certain kinds of errors in the very first grammar
> >
> > - element could cause the construction of a malformed graph
> >
> > + element could cause the construction of a malformed graph
> >
> > representing the grammar. This would eventually result in a
> >
> > fatal internal error. The code has been changed to be more
> >
> > resistant to this particular error.
> >
> >
> >
> > -#255. (MR21a) ParserBlackBox(FILE* f)
> >
> > +#255. (MR21a) ParserBlackBox(FILE* f)
> >
> >
> >
> > This constructor set openByBlackBox to the wrong value.
> >
> >
> >
> > @@ -813,14 +813,14 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > AParser.h. If this preprocessor symbol was not properly
> >
> > set the first time AParser.h was #included, the declaration
> >
> > of zzTRACEdata would be omitted (it is used by the -gd option).
> >
> > - Subsequent #includes of AParser.h would be skipped because of
> >
> > + Subsequent #includes of AParser.h would be skipped because of
> >
> > the #ifdef guard, so the declaration of zzTracePrevRuleName would
> >
> > - never be made. The result was that proper compilation was very
> >
> > + never be made. The result was that proper compilation was very
> >
> > order dependent.
> >
> >
> >
> > The declaration of zzTRACEdata was made unconditional and the
> >
> > problem of removing unused declarations will be left to optimizers.
> >
> > -
> >
> > +
> >
> > Diagnosed by Douglas E. Forester (dougf projtech.com).
> >
> >
> >
> > #250. (MR21) Option for EXPERIMENTAL change to error sets for blocks
> >
> > @@ -835,13 +835,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > the most appropriate tokens in the error message. The error sets used
> >
> > in pccts error messages are approximations of the exact error set when
> >
> > optional elements in (...)* or (...)+ are involved. While entirely
> >
> > - correct, the error messages are sometimes not 100% accurate.
> >
> > + correct, the error messages are sometimes not 100% accurate.
> >
> >
> >
> > There is also a minor philosophical issue. For example, suppose the
> >
> > - grammar expects the token to be an optional A followed by Z, and it
> >
> > + grammar expects the token to be an optional A followed by Z, and it
> >
> > is X. X, of course, is neither A nor Z, so an error message is appropriate.
> >
> > Is it appropriate to say "Expected Z" ? It is correct, it is accurate,
> >
> > - but it is not complete.
> >
> > + but it is not complete.
> >
> >
> >
> > When k>1 or ck>1 the problem of providing the exactly correct
> >
> > list of tokens for the syntax error messages ends up becoming
> >
> > @@ -852,7 +852,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > This application uses the error set in an interactive command language
> >
> > to provide prompts which list the alternatives available at that
> >
> > point in the parser. The user can then enter additional tokens to
> >
> > - complete the command line. To do this required more accurate error
> >
> > + complete the command line. To do this required more accurate error
> >
> > sets then previously provided by pccts.
> >
> >
> >
> > In some cases the default pccts behavior may lead to more robust error
> >
> > @@ -972,7 +972,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > This includes the choice of looping back to the
> >
> > star block.
> >
> > -
> >
> > +
> >
> > #249. (MR21) Changes for DEC/VMS systems
> >
> >
> >
> > Jean-Fran�ois Pi�ronne (jfp altavista.net) has updated some
> >
> > @@ -991,7 +991,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > rr : #FirstSetSymbol(rr_FirstSet) ( Foo | Bar ) ;
> >
> >
> >
> > This will generate the symbol rr_FirstSet of type SetWordType with
> >
> > - elements Foo and Bar set. The bits can be tested using code similar
> >
> > + elements Foo and Bar set. The bits can be tested using code similar
> >
> > to the following:
> >
> >
> >
> > if (set_el(Foo, &rr_FirstSet)) { ...
> >
> > @@ -999,9 +999,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > This can be combined with the C array zztokens[] or the C++ routine
> >
> > tokenName() to get the print name of the token in the first set.
> >
> >
> >
> > - The size of the set is given by the newly added enum SET_SIZE, a
> >
> > + The size of the set is given by the newly added enum SET_SIZE, a
> >
> > protected member of the generated parser's class. The number of
> >
> > - elements in the generated set will not be exactly equal to the
> >
> > + elements in the generated set will not be exactly equal to the
> >
> > value of SET_SIZE because of synthetic tokens created by #tokclass,
> >
> > #errclass, the -ge option, and meta-tokens such as epsilon, and
> >
> > end-of-file.
> >
> > @@ -1015,11 +1015,11 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > rr_bad : #FirstSetSymbol(rr_bad_FirstSet) Foo; // Illegal
> >
> >
> >
> > rr_ok : #FirstSetSymbol(rr_ok_FirstSet) (Foo); // Legal
> >
> > -
> >
> > +
> >
> > Do not confuse FirstSetSymbol sets with the sets used for testing
> >
> > lookahead. The sets used for FirstSetSymbol have one element per bit,
> >
> > so the number of bytes is approximately the largest token number
> >
> > - divided by 8. The sets used for testing lookahead store 8 lookahead
> >
> > + divided by 8. The sets used for testing lookahead store 8 lookahead
> >
> > sets per byte, so the length of the array is approximately the largest
> >
> > token number.
> >
> >
> >
> > @@ -1033,7 +1033,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > ===================================================
> >
> >
> >
> > Prior to MR21, tokens which were optional did not appear in syntax
> >
> > - error messages if the block which immediately followed detected a
> >
> > + error messages if the block which immediately followed detected a
> >
> > syntax error.
> >
> >
> >
> > Consider the following grammar which accepts Number, Word, and Other:
> >
> > @@ -1071,7 +1071,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > }
> >
> > }
> >
> > match(Word);
> >
> > -
> >
> > +
> >
> > The code generated for optional blocks in MR21 is slightly longer
> >
> > than the previous versions, but it should give better error messages.
> >
> >
> >
> > @@ -1098,14 +1098,14 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > The following command line options have been added to genmk:
> >
> >
> >
> > - -cfiles ...
> >
> > -
> >
> > + -cfiles ...
> >
> > +
> >
> > To add a user's C or C++ files into makefile automatically.
> >
> > The list of files must be enclosed in apostrophes. This
> >
> > option may be specified multiple times.
> >
> >
> >
> > -compiler ...
> >
> > -
> >
> > +
> >
> > The name of the compiler to use for $(CCC) or $(CC). The
> >
> > default in C++ mode is "CC". The default in C mode is "cc".
> >
> >
> >
> > @@ -1139,15 +1139,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > *** NOT IMPLEMENTED ***
> >
> > ***********************
> >
> >
> >
> > - The PURIFY macro was changed to a no-op because it was causing
> >
> > + The PURIFY macro was changed to a no-op because it was causing
> >
> > problems when passing C++ objects.
> >
> > -
> >
> > +
> >
> > The old definition:
> >
> > -
> >
> > +
> >
> > #define PURIFY(r,s) memset((char *) &(r),'\\0',(s));
> >
> > -
> >
> > +
> >
> > The new definition:
> >
> > -
> >
> > +
> >
> > #define PURIFY(r,s) /* nothing */
> >
> > #endif
> >
> >
> >
> > @@ -1174,10 +1174,10 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Should have known better.
> >
> >
> >
> > #237. (Changed in MR21) ParserBlackBox(FILE*)
> >
> > -
> >
> > +
> >
> > In the past, ParserBlackBox would close the FILE in the dtor
> >
> > even though it was not opened by ParserBlackBox. The problem
> >
> > - is that there were two constructors, one which accepted a file
> >
> > + is that there were two constructors, one which accepted a file
> >
> > name and did an fopen, the other which accepted a FILE and did
> >
> > not do an fopen. There is now an extra member variable which
> >
> > remembers whether ParserBlackBox did the open or not.
> >
> > @@ -1186,7 +1186,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > #236. (Changed in MR21) tmake now reports down pointer problem
> >
> >
> >
> > - When ASTBase::tmake attempts to update the down pointer of
> >
> > + When ASTBase::tmake attempts to update the down pointer of
> >
> > an AST it checks to see if the down pointer is NULL. If it
> >
> > is not NULL it does not do the update and returns NULL.
> >
> > An attempt to update the down pointer is almost always a
> >
> > @@ -1221,7 +1221,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > #232. (Changed in MR20) Make setwd bit vectors protected in parser.h
> >
> >
> >
> > The access for the setwd array in the parser header was not
> >
> > - specified. As a result, it would depend on the code which
> >
> > + specified. As a result, it would depend on the code which
> >
> > preceded it. In MR20 it will always have access "protected".
> >
> >
> >
> > Reported by Piotr Eljasiak (eljasiak zt.gdansk.tpsa.pl).
> >
> > @@ -1273,8 +1273,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > resized for deeply nested blocks. This has been fixed.
> >
> >
> >
> > #226. (Changed in MR20) -pedantic conformance
> >
> > -
> >
> > - G. Hobbelt (i_a mbh.org) and THM made many, many minor
> >
> > +
> >
> > + G. Hobbelt (i_a mbh.org) and THM made many, many minor
> >
> > changes to create prototypes for all the functions and
> >
> > bring antlr, dlg, and sorcerer into conformance with
> >
> > the gcc -pedantic option.
> >
> > @@ -1284,7 +1284,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > #225 (Changed in MR20) AST stack adjustment in C mode
> >
> >
> >
> > - The fix in #214 for AST stack adjustment in C mode missed
> >
> > + The fix in #214 for AST stack adjustment in C mode missed
> >
> > some cases.
> >
> >
> >
> > Reported with fix by Ger Hobbelt (i_a mbh.org).
> >
> > @@ -1299,7 +1299,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > #223 (Changed in MR20) Addition of IBM_VISUAL_AGE directory
> >
> >
> >
> > - Build files for antlr, dlg, and sorcerer under IBM Visual Age
> >
> > + Build files for antlr, dlg, and sorcerer under IBM Visual Age
> >
> > have been contributed by Anton Sergeev (ags mlc.ru). They have
> >
> > been placed in the pccts/IBM_VISUAL_AGE directory.
> >
> >
> >
> > @@ -1317,7 +1317,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > The arguments to strcat are reversed when creating a print
> >
> > name for a hash table entry for use with #pred feature.
> >
> >
> >
> > - Problem diagnosed and fix reported by Scott Harrington
> >
> > + Problem diagnosed and fix reported by Scott Harrington
> >
> > (seh4 ix.netcom.com).
> >
> >
> >
> > #219. (Changed in MR19) C Mode routine zzfree_ast
> >
> > @@ -1334,7 +1334,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Implemented by SAKAI Kiyotaka (ksakai isr.co.jp).
> >
> >
> >
> > #217. (Changed in MR19) Error message when dlg -i and -CC options selected
> >
> > -
> >
> > +
> >
> > *** This change was rescinded by item #257 ***
> >
> >
> >
> > The parsers generated by pccts in C++ mode are not able to support the
> >
> > @@ -1353,13 +1353,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > This requires max(k,ck) tokens of lookahead. For some applications
> >
> > this can cause deadlock problems. For example, there may be cases
> >
> > when the parser can't tell when the input has been completely consumed
> >
> > - until the parse is complete, but the parse can't be completed because
> >
> > + until the parse is complete, but the parse can't be completed because
> >
> > the input routines are waiting for additional tokens to fill the
> >
> > lookahead buffer.
> >
> > -
> >
> > - When the ANTLRParser class is built with the pre-processor option
> >
> > +
> >
> > + When the ANTLRParser class is built with the pre-processor option
> >
> > ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
> >
> > - until LA(i) or LT(i) is called.
> >
> > + until LA(i) or LT(i) is called.
> >
> >
> >
> > To test whether this option has been built into the ANTLRParser class
> >
> > use "isDeferFetchEnabled()".
> >
> > @@ -1368,8 +1368,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > routines will defeat the effort to defer the fetch because the
> >
> > trace routines print out information about the lookahead token at
> >
> > the start of the rule.
> >
> > -
> >
> > - Because the tracein and traceout routines are virtual it is
> >
> > +
> >
> > + Because the tracein and traceout routines are virtual it is
> >
> > easy to redefine them in your parser:
> >
> >
> >
> > class MyParser {
> >
> > @@ -1379,9 +1379,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > virtual void traceout(ANTLRChar * ruleName)
> >
> > { fprintf(stderr,"Leaving: %s\n", ruleName); }
> >
> > >>
> >
> > -
> >
> > +
> >
> > The originals for those routines are pccts/h/AParser.cpp
> >
> > -
> >
> > +
> >
> > This requires use of the dlg option -i (interactive lexer).
> >
> >
> >
> > This is implemented only for C++ mode.
> >
> > @@ -1434,9 +1434,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > pccts/sorcerer/sor.r
> >
> > pccts/sorcerer/sor68K.make
> >
> > pccts/sorcerer/sorPPC.make
> >
> > -
> >
> > +
> >
> > They completely replace the previous Mac installation files.
> >
> > -
> >
> > +
> >
> > b. The most significant is a change in the MAC_FILE_CREATOR symbol
> >
> > in pcctscfg.h:
> >
> >
> >
> > @@ -1468,7 +1468,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > PCCTS in the same source file. The problem is caused by the
> >
> > redefinition of setjmp in the MS header file setjmp.h. In
> >
> > setjmp.h the pre-processor symbol setjmp was redefined to be
> >
> > - _setjmp. A later effort to execute #include <setjmp.h> resulted
> >
> > + _setjmp. A later effort to execute #include <setjmp.h> resulted
> >
> > in an effort to #include <_setjmp.h>. I'm not sure whether this
> >
> > is a bug or a feature. In any case, I decided to fix it by
> >
> > avoiding the use of pre-processor symbols in #include statements
> >
> > @@ -1484,7 +1484,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > #ifndef __PCCTS_SETJMP_H__
> >
> > #define __PCCTS_SETJMP_H__
> >
> > -
> >
> > +
> >
> > #ifdef PCCTS_USE_NAMESPACE_STD
> >
> > #include <Csetjmp>
> >
> > #else
> >
> > @@ -1492,7 +1492,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > #endif
> >
> >
> >
> > #endif
> >
> > -
> >
> > +
> >
> > A similar change has been made for other standard header files
> >
> > required by pccts and sorcerer: stdlib.h, stdarg.h, stdio.h, etc.
> >
> >
> >
> > @@ -1522,13 +1522,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> >
> >
> > if ($$.letter > $2.letter) {
> >
> > error("invalid range ", zzline);
> >
> > - }
> >
> > + }
> >
> >
> >
> > The fix is:
> >
> >
> >
> > if ($$.letter > $2.letter && 255 != $$2.letter) {
> >
> > error("invalid range ", zzline);
> >
> > - }
> >
> > + }
> >
> >
> >
> > #206. (Changed in MR16) Free zzFAILtext in ANTLRParser destructor
> >
> >
> >
> > @@ -1544,7 +1544,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > Suggested by Dale Davis (daldavis spectrace.com)
> >
> >
> >
> > #204. (Changed in MR15a) Change __WATCOM__ to __WATCOMC__ in pcctscfg.h
> >
> > -
> >
> > +
> >
> > Reported by Oleg Dashevskii (olegdash my-dejanews.com).
> >
> >
> >
> > #203. (Changed in MR15) Addition of sorcerer to distribution kit
> >
> > @@ -1562,7 +1562,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
> > .cpp files in the pccts/h directory.
> >
> >
> >
> > The library build will create pccts_debug.lib or pccts_release.lib
> >
> > - according to the configuration selected.
> >
> > + according to the configuration selected.
> >
> >
> >
> > If you don't want to build pccts 1.33MR15 you can download a
> >
> > ready-to-run kit for win32 from http://www.polhode.com/win32.zip.
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
> > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
> > index 33d7d20a6a3c..b95615d8a3c1 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
> > @@ -2143,7 +2143,7 @@
> >
> >
> > --------------------------------------------------
> >
> > Note: This was incorrect. The contexts should be
> >
> > - ORed together. This has been fixed. A more
> >
> > + ORed together. This has been fixed. A more
> >
> > complete description is available in item #152.
> >
> > ---------------------------------------------------
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
> > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
> > index 7134500e2fbf..2c371954661f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
> > @@ -42,9 +42,9 @@
> >
> >
> > #216. Defer token fetch for C++ mode
> >
> >
> >
> > - When the ANTLRParser class is built with the pre-processor option
> >
> > + When the ANTLRParser class is built with the pre-processor option
> >
> > ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
> >
> > - until LA(i) or LT(i) is called.
> >
> > + until LA(i) or LT(i) is called.
> >
> >
> >
> > #215. Use reset() to reset DLGLexerBase
> >
> > #188. Added pccts/h/DLG_stream_input.h
> >
> > @@ -1684,7 +1684,7 @@
> >
> >
> > --------------------------------------------------
> >
> > Note: This was incorrect. The contexts should be
> >
> > - ORed together. This has been fixed. A more
> >
> > + ORed together. This has been fixed. A more
> >
> > complete description is available in item #152.
> >
> > ---------------------------------------------------
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
> > index 539cf775257b..cc5cad73897e 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
> > @@ -8,28 +8,28 @@
> > See item #207.
> >
> >
> >
> > Reported by Frank Hartmann.
> >
> > -
> >
> > +
> >
> > #16. A note about "&&" predicates (Mike Dimmick)
> >
> >
> >
> > Mike Dimmick has pointed out a potential pitfall in the use of the
> >
> > "&&" style predicate. Consider:
> >
> > -
> >
> > +
> >
> > r0: (g)? => <<P>>? r1
> >
> > | ...
> >
> > ;
> >
> > r1: A | B;
> >
> > -
> >
> > +
> >
> > If the context guard g is not a subset of the lookahead context for r1
> >
> > - (in other words g is neither A nor B) then the code may execute r1
> >
> > + (in other words g is neither A nor B) then the code may execute r1
> >
> > even when the lookahead context is not satisfied. This is an error
> >
> > by the person coding the grammar, and the error should be reported to
> >
> > the user, but it isn't. expect. Some examples I've run seem to
> >
> > indicate that such an error actually results in the rule becoming
> >
> > unreachable.
> >
> > -
> >
> > +
> >
> > When g is properly coded the code is correct, the problem is when g
> >
> > is not properly coded.
> >
> > -
> >
> > +
> >
> > A second problem reported by Mike Dimmick is that the test for a
> >
> > failed validation predicate is equivalent to a test on the predicate
> >
> > along. In other words, if the "&&" has not been hoisted then it may
> >
> > @@ -53,7 +53,7 @@
> >
> >
> > This behavior should be changed, but it appears in too many programs
> >
> > now. Another problem, perhaps more significant, is that the obvious
> >
> > - fix (moving the consume() call to before the action) could change the
> >
> > + fix (moving the consume() call to before the action) could change the
> >
> > order in which input is requested and output appears in existing programs.
> >
> >
> >
> > This problem was reported, along with a fix by Benjamin Mandel
> >
> > @@ -85,12 +85,12 @@
> > GraphPtr g;
> >
> > {
> >
> > Graph g1, g2;
> >
> > -
> >
> > +
> >
> > if ( andExpr(&g1) == -1 )
> >
> > {
> >
> > return -1;
> >
> > }
> >
> > -
> >
> > +
> >
> > while ( token == '|' )
> >
> > {
> >
> > int a;
> >
> > @@ -100,7 +100,7 @@
> > else if ( !a ) return 1; /* empty alternative */
> >
> > g1 = BuildNFA_AorB(g1, g2);
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( token!='\0' ) return -1;
> >
> > *****
> >
> > ***** It appears to fail here becuause token is 125 - the closing '}'
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
> > index 58d0b134b9d8..c71f6cc31aa3 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
> > @@ -59,7 +59,7 @@ static int class_nest_level = 0;
> >
> >
> > /* MR20 G. Hobbelt extern definitions moved to antlr.h */
> >
> >
> >
> > -
> >
> > +
> >
> >
> >
> > void
> >
> > #ifdef __USE_PROTOS
> >
> > @@ -82,7 +82,7 @@ grammar()
> > if ( (LA(1)==94) ) {
> >
> > zzmatch(94); zzCONSUME;
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > if ( HdrAction==NULL ) {
> >
> > HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
> >
> > @@ -96,7 +96,7 @@ grammar()
> > if ( (LA(1)==95) ) {
> >
> > zzmatch(95); zzCONSUME;
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > if ( FirstAction==NULL ) {
> >
> > FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
> >
> > @@ -111,7 +111,7 @@ grammar()
> > if ( (LA(1)==96) ) {
> >
> > zzmatch(96); zzCONSUME;
> >
> > zzmatch(QuotedTerm);
> >
> > -
> >
> > +
> >
> > if ( GenCC ) {
> >
> > warn("#parser meta-op incompatible with -CC; ignored");
> >
> > }
> >
> > @@ -221,7 +221,7 @@ grammar()
> > else {
> >
> > if ( (LA(1)==98) ) {
> >
> > zzmatch(98);
> >
> > -
> >
> > +
> >
> > if ( class_nest_level==0 )
> >
> > warn("missing class definition for trailing '}'");
> >
> > class_nest_level--;
> >
> > @@ -257,7 +257,7 @@ grammar()
> > rule();
> >
> > if ( zzaArg(zztasp2,1 ).left!=NULL ) {
> >
> > g.right = NULL;
> >
> > -
> >
> > +
> >
> > /* MR21a */ /* Avoid use of a malformed graph when CannotContinue */
> >
> > /* MR21a */ /* is already set */
> >
> > /* MR21a */
> >
> > @@ -293,7 +293,7 @@ grammar()
> > else {
> >
> > if ( (LA(1)==98) ) {
> >
> > zzmatch(98);
> >
> > -
> >
> > +
> >
> > if ( class_nest_level==0 )
> >
> > warn("missing class definition for trailing '}'");
> >
> > class_nest_level--;
> >
> > @@ -361,7 +361,7 @@ grammar()
> > else {
> >
> > if ( (LA(1)==98) ) {
> >
> > zzmatch(98);
> >
> > -
> >
> > +
> >
> > if ( class_nest_level==0 )
> >
> > warn("missing class definition for trailing '}'");
> >
> > class_nest_level--;
> >
> > @@ -387,7 +387,7 @@ grammar()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd1, 0x10);
> >
> > }
> >
> > @@ -428,7 +428,7 @@ class_def()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
> >
> > && GenCC ) {
> >
> > err("only one grammar class allowed in this release");
> >
> > @@ -468,7 +468,7 @@ class_def()
> > }
> >
> > }
> >
> > zzmatch(102);
> >
> > -
> >
> > +
> >
> > no_classes_found = 0;
> >
> > if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
> >
> > else class_nest_level++;
> >
> > @@ -478,7 +478,7 @@ class_def()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd1, 0x40);
> >
> > }
> >
> > @@ -495,8 +495,8 @@ rule()
> > zzBLOCK(zztasp1);
> >
> > zzMake0;
> >
> > {
> >
> > -
> >
> > -
> >
> > +
> >
> > +
> >
> > ExceptionGroup *eg;
> >
> > RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
> >
> > set toksrefd, rulesrefd;
> >
> > @@ -621,7 +621,7 @@ rule()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( GenEClasseForRules && q!=NULL ) {
> >
> > e = newECnode;
> >
> > require(e!=NULL, "cannot allocate error class node");
> >
> > @@ -672,9 +672,9 @@ rule()
> > CurRuleBlk->end = p;
> >
> > if ( q!=NULL ) q->rulenum = NumRules;
> >
> > zzaArg(zztasp1,7) = r;
> >
> > -
> >
> > +
> >
> > /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
> >
> > - /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > + /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > --BlkLevel;
> >
> > altFixup();leFixup();egFixup();
> >
> > zzmatch(107);
> >
> > @@ -727,7 +727,7 @@ rule()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd2, 0x10);
> >
> > }
> >
> > @@ -747,7 +747,7 @@ laction()
> > char *a;
> >
> > zzmatch(108); zzCONSUME;
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(a!=NULL, "rule laction: cannot allocate action");
> >
> > strcpy(a, LATEXT(1));
> >
> > @@ -758,7 +758,7 @@ laction()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd2, 0x20);
> >
> > }
> >
> > @@ -778,7 +778,7 @@ lmember()
> > char *a;
> >
> > zzmatch(109); zzCONSUME;
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > /* MR1 */ if (! GenCC) {
> >
> > /* MR1 */ err("Use #lexmember only in C++ mode (to insert code in DLG class header");
> >
> > /* MR1 */ } else {
> >
> > @@ -794,7 +794,7 @@ lmember()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd2, 0x40);
> >
> > }
> >
> > @@ -814,7 +814,7 @@ lprefix()
> > char *a;
> >
> > zzmatch(110); zzCONSUME;
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > /* MR1 */ if (! GenCC) {
> >
> > /* MR1 */ err("Use #lexprefix only in C++ mode (to insert code in DLG class header");
> >
> > /* MR1 */ } else {
> >
> > @@ -830,7 +830,7 @@ lprefix()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd2, 0x80);
> >
> > }
> >
> > @@ -855,7 +855,7 @@ aPred()
> > int save_line;
> >
> > int predExprPresent=0;
> >
> > zzmatch(111);
> >
> > -
> >
> > +
> >
> > MR_usingPredNames=1; /* will need to use -mrhoist version of genPredTree */
> >
> > zzCONSUME;
> >
> >
> >
> > @@ -863,13 +863,13 @@ aPred()
> > name=mystrdup(LATEXT(1));
> >
> > zzCONSUME;
> >
> >
> >
> > -
> >
> > +
> >
> > /* don't free - referenced in predicates */
> >
> > -
> >
> > +
> >
> > CurPredName=(char *)calloc(1,strlen(name) + 10);
> >
> > strcat(CurPredName,"#pred ");
> >
> > strcat(CurPredName,name);
> >
> > -
> >
> > +
> >
> > predEntry=(PredEntry *) hash_get(Pname,name);
> >
> > if (predEntry != NULL) {
> >
> > warnFL(eMsg1("#pred %s previously defined - ignored",name),
> >
> > @@ -905,12 +905,12 @@ aPred()
> > }
> >
> > }
> >
> > if (predLiteral != NULL && name != NULL) {
> >
> > -
> >
> > +
> >
> > /*
> >
> > * predExpr may be NULL due to syntax errors
> >
> > * or simply omitted by the user
> >
> > */
> >
> > -
> >
> > +
> >
> > predEntry=newPredEntry(name);
> >
> > predEntry->file=save_file;
> >
> > predEntry->line=save_line;
> >
> > @@ -997,7 +997,7 @@ predOrExpr()
> > Predicate **tail=NULL;
> >
> > predExpr = predAndExpr();
> >
> >
> >
> > -
> >
> > +
> >
> > ORnode=new_pred();
> >
> > ORnode->expr=PRED_OR_LIST;
> >
> > if (predExpr != NULL) {
> >
> > @@ -1012,7 +1012,7 @@ predOrExpr()
> > zzmatch(112); zzCONSUME;
> >
> > predExpr = predAndExpr();
> >
> >
> >
> > -
> >
> > +
> >
> > if (predExpr != NULL) {
> >
> > *tail=predExpr;
> >
> > tail=&predExpr->right;
> >
> > @@ -1022,14 +1022,14 @@ predOrExpr()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > _retv=ORnode;
> >
> > ORnode=NULL;
> >
> > zzEXIT(zztasp1);
> >
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - predicate_free(ORnode);
> >
> > + predicate_free(ORnode);
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd3, 0x20);
> >
> > return _retv;
> >
> > @@ -1054,7 +1054,7 @@ predAndExpr()
> > Predicate **tail=NULL;
> >
> > predExpr = predPrimary();
> >
> >
> >
> > -
> >
> > +
> >
> > ANDnode=new_pred();
> >
> > ANDnode->expr=PRED_AND_LIST;
> >
> > if (predExpr != NULL) {
> >
> > @@ -1069,7 +1069,7 @@ predAndExpr()
> > zzmatch(113); zzCONSUME;
> >
> > predExpr = predPrimary();
> >
> >
> >
> > -
> >
> > +
> >
> > if (predExpr != NULL) {
> >
> > *tail=predExpr;
> >
> > tail=&predExpr->right;
> >
> > @@ -1079,14 +1079,14 @@ predAndExpr()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > _retv=ANDnode;
> >
> > ANDnode=NULL;
> >
> > zzEXIT(zztasp1);
> >
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - predicate_free(ANDnode);
> >
> > + predicate_free(ANDnode);
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd3, 0x40);
> >
> > return _retv;
> >
> > @@ -1106,7 +1106,7 @@ predPrimary()
> > PCCTS_PURIFY(_retv,sizeof(Predicate * ))
> >
> > zzMake0;
> >
> > {
> >
> > -
> >
> > +
> >
> > char *name=NULL;
> >
> > PredEntry *predEntry=NULL;
> >
> > Predicate *predExpr=NULL;
> >
> > @@ -1115,7 +1115,7 @@ predPrimary()
> > name=mystrdup(LATEXT(1));
> >
> > zzCONSUME;
> >
> >
> >
> > -
> >
> > +
> >
> > predEntry=(PredEntry *) hash_get(Pname,name);
> >
> > if (predEntry == NULL) {
> >
> > warnFL(eMsg1("no previously defined #pred with name \"%s\"",name),
> >
> > @@ -1134,7 +1134,7 @@ predPrimary()
> > predExpr = predOrExpr();
> >
> >
> >
> > zzmatch(115);
> >
> > -
> >
> > +
> >
> > _retv=predExpr;
> >
> > zzCONSUME;
> >
> >
> >
> > @@ -1144,7 +1144,7 @@ predPrimary()
> > zzmatch(103); zzCONSUME;
> >
> > predExpr = predPrimary();
> >
> >
> >
> > -
> >
> > +
> >
> > predExpr->inverted=!predExpr->inverted;
> >
> > _retv=predExpr;
> >
> > }
> >
> > @@ -1155,7 +1155,7 @@ predPrimary()
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > -
> >
> > +
> >
> > predicate_free(predExpr);
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd3, 0x80);
> >
> > @@ -1183,7 +1183,7 @@ aLexclass()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd4, 0x1);
> >
> > }
> >
> > @@ -1323,7 +1323,7 @@ error()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd4, 0x4);
> >
> > }
> >
> > @@ -1390,7 +1390,7 @@ tclass()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (p!= NULL && akaString != NULL) {
> >
> > /* MR23 */ if (p->akaString != NULL) {
> >
> > /* MR23 */ if (strcmp(p->akaString,akaString) != 0) {
> >
> > @@ -1493,7 +1493,7 @@ tclass()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd4, 0x20);
> >
> > }
> >
> > @@ -1599,7 +1599,7 @@ token()
> > {
> >
> > if ( (LA(1)==Action) ) {
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(a!=NULL, "rule token: cannot allocate action");
> >
> > strcpy(a, LATEXT(1));
> >
> > @@ -1648,7 +1648,7 @@ token()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd5, 0x10);
> >
> > }
> >
> > @@ -1667,7 +1667,7 @@ set *rulesrefd ;
> > zzBLOCK(zztasp1);
> >
> > zzMake0;
> >
> > {
> >
> > -
> >
> > +
> >
> > Graph g, b;
> >
> > set saveblah;
> >
> > int saveinalt = inAlt;
> >
> > @@ -1678,12 +1678,12 @@ set *rulesrefd ;
> > CurBlockID++;
> >
> > /* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
> >
> > CurAltNum = 1;
> >
> > - /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
> >
> > + /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
> >
> > saveblah = attribsRefdFromAction;
> >
> > attribsRefdFromAction = empty;
> >
> > alt( toksrefd,rulesrefd );
> >
> > b = g = zzaArg(zztasp1,1);
> >
> > -
> >
> > +
> >
> > if ( ((Junction *)g.left)->p1->ntype == nAction )
> >
> > {
> >
> > ActionNode *actionNode=(ActionNode *)
> >
> > @@ -1705,7 +1705,7 @@ set *rulesrefd ;
> > while ( (LA(1)==133) ) {
> >
> > eg = exception_group();
> >
> >
> >
> > -
> >
> > +
> >
> > if ( eg!=NULL ) {
> >
> > /* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
> >
> > /* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
> >
> > @@ -1729,7 +1729,7 @@ set *rulesrefd ;
> >
> >
> > alt( toksrefd,rulesrefd );
> >
> > g = Or(g, zzaArg(zztasp2,2));
> >
> > -
> >
> > +
> >
> > ((Junction *)g.left)->blockid = CurBlockID;
> >
> > {
> >
> > zzBLOCK(zztasp3);
> >
> > @@ -1738,7 +1738,7 @@ set *rulesrefd ;
> > while ( (LA(1)==133) ) {
> >
> > eg = exception_group();
> >
> >
> >
> > -
> >
> > +
> >
> > if ( eg!=NULL ) {
> >
> > /* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
> >
> > /* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
> >
> > @@ -1762,7 +1762,7 @@ set *rulesrefd ;
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd5, 0x20);
> >
> > }
> >
> > @@ -1784,7 +1784,7 @@ set *rulesrefd ;
> > int n=0; Graph g; int e_num=0, old_not=0; Node *node; set elems, dif;
> >
> > int first_on_line = 1, use_def_MT_handler = 0;
> >
> > g.left=NULL; g.right=NULL;
> >
> > -
> >
> > +
> >
> > CurAltStart = NULL;
> >
> > elems = empty;
> >
> > inAlt = 1;
> >
> > @@ -1834,7 +1834,7 @@ set *rulesrefd ;
> > node = element( old_not, first_on_line, use_def_MT_handler );
> >
> >
> >
> > if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;
> >
> > -
> >
> > +
> >
> > if ( zzaArg(zztasp2,2 ).left!=NULL ) {
> >
> > g = Cat(g, zzaArg(zztasp2,2));
> >
> > n++;
> >
> > @@ -1888,7 +1888,7 @@ inAlt = 0;
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd6, 0x2);
> >
> > }
> >
> > @@ -1912,7 +1912,7 @@ element_label()
> > lab = mystrdup(LATEXT(1));
> >
> > zzCONSUME;
> >
> >
> >
> > -
> >
> > +
> >
> > UsedNewStyleLabel = 1;
> >
> > if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
> >
> > t = (TermEntry *) hash_get(Tname, lab);
> >
> > @@ -1970,7 +1970,7 @@ int use_def_MT_handler ;
> > PCCTS_PURIFY(_retv,sizeof(Node * ))
> >
> > zzMake0;
> >
> > {
> >
> > -
> >
> > +
> >
> > Attrib blk;
> >
> > Predicate *pred = NULL;
> >
> > int local_use_def_MT_handler=0;
> >
> > @@ -1985,9 +1985,9 @@ int use_def_MT_handler ;
> > int ampersandStyle;
> >
> > int height; /* MR11 */
> >
> > int equal_height; /* MR11 */
> >
> > -
> >
> > +
> >
> > char* pFirstSetSymbol = NULL; /* MR21 */
> >
> > -
> >
> > +
> >
> > _retv = NULL;
> >
> > if ( (setwd6[LA(1)]&0x8) ) {
> >
> > {
> >
> > @@ -2012,7 +2012,7 @@ int use_def_MT_handler ;
> > {
> >
> > if ( (LA(1)==TokenTerm) ) {
> >
> > zzmatch(TokenTerm);
> >
> > -
> >
> > +
> >
> > term = (TermEntry *) hash_get(Tname, LATEXT(1));
> >
> > if ( term==NULL && UserDefdTokens ) {
> >
> > err("implicit token definition not allowed with #tokdefs");
> >
> > @@ -2069,7 +2069,7 @@ int use_def_MT_handler ;
> > zzEXIT(zztasp3);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
> >
> > list_add(&MetaTokenNodes, (void *)p);
> >
> > {
> >
> > @@ -2117,7 +2117,7 @@ int use_def_MT_handler ;
> > zzEXIT(zztasp3);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( p!=NULL && first_on_line ) {
> >
> > CurAltStart = (Junction *)zzaRet.left;
> >
> > altAdd(CurAltStart); /* MR7 */
> >
> > @@ -2130,7 +2130,7 @@ int use_def_MT_handler ;
> > else {
> >
> > if ( (LA(1)==QuotedTerm) ) {
> >
> > zzmatch(QuotedTerm);
> >
> > -
> >
> > +
> >
> > term = (TermEntry *) hash_get(Texpr, LATEXT(1));
> >
> > if ( term==NULL && UserDefdTokens ) {
> >
> > err("implicit token definition not allowed with #tokdefs");
> >
> > @@ -2228,10 +2228,10 @@ int use_def_MT_handler ;
> > zzEXIT(zztasp3);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
> >
> > list_add(&MetaTokenNodes, (void *)p);
> >
> > -
> >
> > +
> >
> > if ( first_on_line ) {
> >
> > CurAltStart = (Junction *)zzaRet.left;
> >
> > altAdd(CurAltStart); /* MR7 */
> >
> > @@ -2276,7 +2276,7 @@ int use_def_MT_handler ;
> > }
> >
> > }
> >
> > list_add(&MetaTokenNodes, (void *)p);
> >
> > -
> >
> > +
> >
> > if ( first_on_line ) {
> >
> > CurAltStart = (Junction *)zzaRet.left;
> >
> > altAdd(CurAltStart); /* MR7 */
> >
> > @@ -2356,7 +2356,7 @@ int use_def_MT_handler ;
> > if ( (LA(1)==105) ) {
> >
> > zzmatch(105); zzCONSUME;
> >
> > zzmatch(PassAction);
> >
> > -
> >
> > +
> >
> > a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(a!=NULL, "rule element: cannot allocate assignment");
> >
> > strcpy(a, LATEXT(1));
> >
> > @@ -2372,7 +2372,7 @@ int use_def_MT_handler ;
> > zzEXIT(zztasp3);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( label!=NULL ) {
> >
> > rr->el_label = label->str;
> >
> > label->elem = (Node *)rr;
> >
> > @@ -2424,7 +2424,7 @@ int use_def_MT_handler ;
> > char *a;
> >
> > if ( (LA(1)==PassAction) ) {
> >
> > zzmatch(PassAction);
> >
> > -
> >
> > +
> >
> > a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(a!=NULL, "rule element: cannot allocate predicate fail action");
> >
> > strcpy(a, LATEXT(1));
> >
> > @@ -2511,7 +2511,7 @@ int use_def_MT_handler ;
> > {
> >
> > if ( (LA(1)==NonTerminal) ) {
> >
> > zzmatch(NonTerminal);
> >
> > -
> >
> > +
> >
> > /* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
> >
> > /* MR21 */ sizeof(char));
> >
> > /* MR21 */ require(pFirstSetSymbol!=NULL,
> >
> > @@ -2524,7 +2524,7 @@ int use_def_MT_handler ;
> > else {
> >
> > if ( (LA(1)==TokenTerm) ) {
> >
> > zzmatch(TokenTerm);
> >
> > -
> >
> > +
> >
> > /* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
> >
> > /* MR21 */ sizeof(char));
> >
> > /* MR21 */ require(pFirstSetSymbol!=NULL,
> >
> > @@ -2559,7 +2559,7 @@ int use_def_MT_handler ;
> > zzmatch(115);
> >
> > blk = zzaRet = zzaArg(zztasp2,2);
> >
> > /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
> >
> > - /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > + /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > --BlkLevel;
> >
> > zzCONSUME;
> >
> >
> >
> > @@ -2627,7 +2627,7 @@ int use_def_MT_handler ;
> > char *a;
> >
> > if ( (LA(1)==PassAction) ) {
> >
> > zzmatch(PassAction);
> >
> > -
> >
> > +
> >
> > a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(a!=NULL, "rule element: cannot allocate predicate fail action");
> >
> > strcpy(a, LATEXT(1));
> >
> > @@ -2648,7 +2648,7 @@ int use_def_MT_handler ;
> > altAdd(CurAltStart); /* MR7 */
> >
> > };
> >
> > _retv = (Node *)act;
> >
> > -
> >
> > +
> >
> > pred = computePredFromContextGuard(blk,&predMsgDone); /* MR10 */
> >
> > if ( pred==NULL) { /* MR10 */
> >
> > if ( !predMsgDone) err("invalid or missing context guard"); /* MR10 */
> >
> > @@ -2707,7 +2707,7 @@ int use_def_MT_handler ;
> > zzEXIT(zztasp3);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( pred==NULL && !predMsgDone) { /* MR10 */
> >
> > ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
> >
> > ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
> >
> > @@ -2725,10 +2725,10 @@ int use_def_MT_handler ;
> > block( &toksrefd,&rulesrefd );
> >
> > zzaRet = makeOpt(zzaArg(zztasp2,2),approx,pFirstSetSymbol);
> >
> > /* MR23 */ CurBlockID_array[BlkLevel] = (-1);
> >
> > - /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > + /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
> >
> > --BlkLevel;
> >
> > zzmatch(98);
> >
> > -
> >
> > +
> >
> > ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
> >
> > ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
> >
> > ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
> >
> > @@ -2787,7 +2787,7 @@ int use_def_MT_handler ;
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd9, 0x1);
> >
> > return _retv;
> >
> > @@ -2842,7 +2842,7 @@ exception_group()
> > char *p;
> >
> > if ( (LA(1)==PassAction) ) {
> >
> > zzmatch(PassAction);
> >
> > -
> >
> > +
> >
> > p = LATEXT(1)+1;
> >
> > p[strlen(p)-1] = '\0'; /* kill trailing space */
> >
> > label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
> >
> > @@ -2906,7 +2906,7 @@ exception_group()
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( label!=NULL ) {
> >
> > /* Record ex group in sym tab for this label */
> >
> > if ( label->ex_group!=NULL ) {
> >
> > @@ -2935,9 +2935,9 @@ exception_group()
> > } /* end switch */
> >
> > /* MR6 */ }; /* end test on label->elem */
> >
> > } /* end test on label->ex_group */
> >
> > -
> >
> > +
> >
> > } /* end test on exception label */
> >
> > -
> >
> > +
> >
> > /* MR7 */
> >
> > /* MR7 */ if (BlkLevel == 1 && label == NULL) {
> >
> > /* MR7 */ _retv->forRule=1;
> >
> > @@ -2958,7 +2958,7 @@ exception_group()
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd9, 0x10);
> >
> > return _retv;
> >
> > @@ -2980,7 +2980,7 @@ exception_handler()
> > {
> >
> > ;
> >
> > zzmatch(135);
> >
> > -
> >
> > +
> >
> > _retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
> >
> > require(_retv!=NULL, "exception: cannot allocate handler");
> >
> > zzCONSUME;
> >
> > @@ -2991,7 +2991,7 @@ exception_handler()
> > {
> >
> > if ( (LA(1)==NonTerminal) ) {
> >
> > zzmatch(NonTerminal);
> >
> > -
> >
> > +
> >
> > _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
> >
> > strcpy(_retv->signalname, LATEXT(1));
> >
> > @@ -3001,7 +3001,7 @@ exception_handler()
> > else {
> >
> > if ( (LA(1)==TokenTerm) ) {
> >
> > zzmatch(TokenTerm);
> >
> > -
> >
> > +
> >
> > _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
> >
> > strcpy(_retv->signalname, LATEXT(1));
> >
> > @@ -3021,7 +3021,7 @@ exception_handler()
> > _retv->action = NULL;
> >
> > if ( (LA(1)==Action) ) {
> >
> > zzmatch(Action);
> >
> > -
> >
> > +
> >
> > _retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
> >
> > require(_retv->action!=NULL, "exception: cannot allocate action");
> >
> > strcpy(_retv->action, LATEXT(1));
> >
> > @@ -3040,7 +3040,7 @@ exception_handler()
> > return _retv;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - CannotContinue=TRUE;
> >
> > + CannotContinue=TRUE;
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd9, 0x40);
> >
> > return _retv;
> >
> > @@ -3159,15 +3159,15 @@ defines(fname)
> > zzCONSUME;
> >
> >
> >
> > zzmatch(INT);
> >
> > -
> >
> > +
> >
> > v = atoi(LATEXT(1));
> >
> > /* fprintf(stderr, "#token %s=%d\n", t, v);*/
> >
> > -
> >
> > +
> >
> > /* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
> >
> > /* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
> >
> > /* MR2 Don't let #tokdefs be confused by */
> >
> > /* MR2 DLGminToken and DLGmaxToken */
> >
> > -
> >
> > +
> >
> > if ( ! isDLGmaxToken(t)) { /* MR2 */
> >
> > TokenNum = v;
> >
> > if ( v>maxt ) maxt=v;
> >
> > @@ -3234,7 +3234,7 @@ enum_def(fname)
> > zzEXIT(zztasp2);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > /* fprintf(stderr, "#token %s=%d\n", t, v);*/
> >
> > TokenNum = v;
> >
> > if ( v>maxt ) maxt=v; /* MR3 */
> >
> > @@ -3298,7 +3298,7 @@ enum_def(fname)
> > zzEXIT(zztasp4);
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > /* fprintf(stderr, "#token %s=%d\n", t, v);*/
> >
> > TokenNum = v;
> >
> > if ( v>maxt ) maxt=v; /* MR3 */
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
> > index 5cb657bb2eee..4f36da950e1e 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
> > @@ -249,7 +249,7 @@ char *eclass;
> > unsigned deg=0;
> >
> > set a;
> >
> > require(eclass!=NULL, "doEclass: NULL eset");
> >
> > -
> >
> > +
> >
> > p = (ECnode *) eclass;
> >
> > lexmode(p->lexclass); /* switch to lexclass where errclass is defined */
> >
> > p->eset = empty;
> >
> > @@ -717,7 +717,7 @@ GenParser_c_Hdr()
> > fprintf(Parser_c, " * with AHPCRC, University of Minnesota\n");
> >
> > fprintf(Parser_c, " * ANTLR Version %s\n", Version);
> >
> > fprintf(Parser_c, " */\n\n");
> >
> > -
> >
> > +
> >
> > if ( FirstAction != NULL ) dumpAction(FirstAction,Parser_c, 0, -1, 0, 1); /* MR11 MR15b */
> >
> >
> >
> > fprintf(Parser_c, "#define ANTLR_VERSION %s\n", VersionDef);
> >
> > @@ -846,7 +846,7 @@ GenParser_h_Hdr()
> > fprintf(Parser_h, "#include \"%s\"\n\n", APARSER_H);
> >
> >
> >
> > if ( HdrAction != NULL ) dumpAction( HdrAction, Parser_h, 0, -1, 0, 1);
> >
> > -
> >
> > +
> >
> > /* MR10 */ if (ClassDeclStuff == NULL) {
> >
> > /* MR10 */ fprintf(Parser_h, "class %s : public ANTLRParser {\n", CurrentClassName);
> >
> > /* MR10 */ } else {
> >
> > @@ -887,7 +887,7 @@ GenErrHdr( )
> > fprintf(ErrFile, " */\n\n");
> >
> >
> >
> > if ( FirstAction != NULL ) dumpAction( FirstAction, ErrFile, 0, -1, 0, 1); /* MR11 MR15b */
> >
> > -
> >
> > +
> >
> > fprintf(ErrFile, "#define ANTLR_VERSION %s\n", VersionDef);
> >
> >
> >
> > fprintf(ErrFile, "#include \"pcctscfg.h\"\n");
> >
> > @@ -916,7 +916,7 @@ GenErrHdr( )
> > if ( DemandLookahead ) fprintf(ErrFile, "#define DEMAND_LOOK\n");
> >
> > fprintf(ErrFile, "#include \"antlr.h\"\n");
> >
> > if ( GenAST ) fprintf(ErrFile, "#include \"ast.h\"\n");
> >
> > -
> >
> > +
> >
> > if ( UserDefdTokens ) fprintf(ErrFile, "#include %s\n", UserTokenDefsFile);
> >
> > /* still need this one as it has the func prototypes */
> >
> > fprintf(ErrFile, "#include \"%s\"\n", DefFileName);
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
> > index 4eb3b02af181..641fa7a1a5d7 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
> > @@ -96,7 +96,7 @@ int is_predicate;
> > Graph g;
> >
> > ActionNode *a;
> >
> > require(action!=NULL, "buildAction: invalid action");
> >
> > -
> >
> > +
> >
> > j1 = newJunction();
> >
> > j2 = newJunction();
> >
> > a = newActionNode();
> >
> > @@ -169,7 +169,7 @@ char *text;
> > Graph g;
> >
> > TokNode *t;
> >
> > require(text!=NULL, "buildToken: invalid token name");
> >
> > -
> >
> > +
> >
> > j1 = newJunction();
> >
> > j2 = newJunction();
> >
> > t = newTokNode();
> >
> > @@ -203,7 +203,7 @@ char *text;
> > TCnode *w;
> >
> > TermEntry *p;
> >
> > require(text!=NULL, "buildWildCard: invalid token name");
> >
> > -
> >
> > +
> >
> > j1 = newJunction();
> >
> > j2 = newJunction();
> >
> > t = newTokNode();
> >
> > @@ -278,7 +278,7 @@ char *text;
> > RuleRefNode *r;
> >
> > RuleEntry *p;
> >
> > require(text!=NULL, "buildRuleRef: invalid rule name");
> >
> > -
> >
> > +
> >
> > j1 = newJunction();
> >
> > j2 = newJunction();
> >
> > r = newRNode();
> >
> > @@ -344,7 +344,7 @@ Graph g2;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > if ( g1.left == NULL && g1.right == NULL ) return g2;
> >
> > if ( g2.left == NULL && g2.right == NULL ) return g1;
> >
> > ((Junction *)g1.right)->p1 = g2.left;
> >
> > @@ -596,7 +596,7 @@ emptyAlt( )
> > j1->p1 = (Node *) j2;
> >
> > g.left = (Node *) j1;
> >
> > g.right = (Node *) j2;
> >
> > -
> >
> > +
> >
> > return g;
> >
> > }
> >
> >
> >
> > @@ -624,7 +624,7 @@ emptyAlt3( )
> > j2->p1 = (Node *) j3;
> >
> > g.left = (Node *) j1;
> >
> > g.right = (Node *) j3;
> >
> > -
> >
> > +
> >
> > return g;
> >
> > }
> >
> >
> >
> > @@ -695,7 +695,7 @@ newRNode( )
> > p->line = zzline;
> >
> > p->astnode = ASTinclude;
> >
> > p->altstart = NULL;
> >
> > -
> >
> > +
> >
> > return p;
> >
> > }
> >
> >
> >
> > @@ -790,7 +790,7 @@ makelocks( )
> > {
> >
> > char *p = (char *) calloc(CLL_k+1, sizeof(char));
> >
> > require(p!=NULL, "cannot allocate lock array");
> >
> > -
> >
> > +
> >
> > return p;
> >
> > }
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
> > index 8156159f7197..2272603c6bc8 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
> > @@ -6,7 +6,7 @@
> > #include "hash.h"
> >
> > #include "generic.h"
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > dumpcycles(void)
> >
> > #else
> >
> > @@ -40,11 +40,11 @@ dumpcycles()
> > };
> >
> > }
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > -dumpfostack(int k)
> >
> > +dumpfostack(int k)
> >
> > #else
> >
> > -dumpfostack(k)
> >
> > +dumpfostack(k)
> >
> > int k;
> >
> > #endif
> >
> > {
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
> > index ba1384dabee0..cc2b8e1de170 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
> > @@ -212,7 +212,7 @@ Junction *alt;
> > altArray[BlkLevel]=alt;
> >
> > }
> >
> >
> >
> > -static void
> >
> > +static void
> >
> > #ifdef __USE_PROTOS
> >
> > arrayCheck(void)
> >
> > #else
> >
> > @@ -252,9 +252,9 @@ arrayCheck()
> >
> >
> > /* always call leFixup() BEFORE egFixup() */
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > -egFixup(void)
> >
> > +egFixup(void)
> >
> > #else
> >
> > egFixup()
> >
> > #endif
> >
> > @@ -277,9 +277,9 @@ egFixup()
> > /* always call leFixup() BEFORE egFixup() */
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > -void leFixup(void)
> >
> > +void leFixup(void)
> >
> > #else
> >
> > -void leFixup()
> >
> > +void leFixup()
> >
> > #endif
> >
> > {
> >
> >
> >
> > @@ -301,7 +301,7 @@ void leFixup()
> > #ifdef __USE_PROTOS
> >
> > void altFixup(void)
> >
> > #else
> >
> > -void altFixup()
> >
> > +void altFixup()
> >
> > #endif
> >
> > {
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
> > index ff7dcdfdd550..cba0b39c638c 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
> > @@ -54,7 +54,7 @@ CacheEntry *dumpFcache1(prev)
> > for (p=table; p<&(table[HashTableSize]); p++) {
> >
> >
> >
> > CacheEntry *q =(CacheEntry *) *p;
> >
> > -
> >
> > +
> >
> > if ( q != NULL && low==0 ) low = p-table;
> >
> > while ( q != NULL ) {
> >
> > if (strcmp(q->str,prev) > 0) {
> >
> > @@ -98,11 +98,11 @@ void reportFcache(q)
> > MR_dumpTokenSet(stdout,1,q->fset);
> >
> > }
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > -DumpFcache(void)
> >
> > +DumpFcache(void)
> >
> > #else
> >
> > -DumpFcache()
> >
> > +DumpFcache()
> >
> > #endif
> >
> > {
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
> > index e3fac09f2a0c..c35e6163afbd 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
> > @@ -231,7 +231,7 @@ set *rk;
> > } else {
> >
> > REACH(p->p1, k, rk, a);
> >
> > }
> >
> > - }
> >
> > + }
> >
> >
> >
> > /* C a c h e R e s u l t s */
> >
> >
> >
> > @@ -273,10 +273,10 @@ set *rk;
> > fprintf(stderr, "\n");
> >
> > #endif
> >
> > }
> >
> > -
> >
> > +
> >
> > if (p->jtype != RuleBlk && p->p2 != NULL && /* MR14 */ ! p->guess) {
> >
> > REACH(p->p2, k, rk, b);
> >
> > - }
> >
> > + }
> >
> >
> >
> > if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
> >
> > p->jtype==aPlusBlk || p->jtype==EndRule )
> >
> > @@ -421,7 +421,7 @@ set *rk;
> > }
> >
> >
> >
> > REACH(p->next, k-1, rk, a);
> >
> > -
> >
> > +
> >
> > if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);
> >
> >
> >
> > return a;
> >
> > @@ -441,7 +441,7 @@ set *rk;
> >
> >
> > require(p!=NULL, "rJunc: NULL node");
> >
> > require(p->ntype==nAction, "rJunc: not action");
> >
> > -
> >
> > +
> >
> > /* MR11 */ if (p->is_predicate && p->ampersandPred != NULL) {
> >
> > /* MR11 */ Predicate *pred=p->ampersandPred;
> >
> > /* MR11 */ if (k <= pred->k) {
> >
> > @@ -1171,7 +1171,7 @@ int jtype;
> > CurAmbigbtype = sub;
> >
> > CurAmbigfile = alt1->file;
> >
> > CurAmbigline = alt1->line;
> >
> > -
> >
> > +
> >
> > /* Don't do full LL(n) analysis if (...)? block because the block,
> >
> > by definition, defies LL(n) analysis.
> >
> > If guess (...)? block and ambiguous then don't remove anything from
> >
> > @@ -1252,9 +1252,9 @@ int jtype;
> > free((char *)ftbl);
> >
> > return;
> >
> > }
> >
> > -
> >
> > +
> >
> > /* Not resolved with (..)? block. Do full LL(n) analysis */
> >
> > -
> >
> > +
> >
> > /* ambig is the set of k-tuples truly in common between alt 1 and alt 2 */
> >
> > /* MR11 VerifyAmbig once used fset destructively */
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
> > index 8a4823a05446..4a69f2e1c68f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
> > @@ -236,7 +236,7 @@ int tok;
> > {
> >
> > Tree *p, *newblk;
> >
> > static int n=0;
> >
> > -
> >
> > +
> >
> > if ( FreeList == NULL )
> >
> > {
> >
> > /*fprintf(stderr, "tnode: %d more nodes\n", TreeBlockAllocSize);*/
> >
> > @@ -346,7 +346,7 @@ Tree *t;
> > #endif
> >
> > {
> >
> > Tree *u;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return NULL;
> >
> > u = tnode(t->token);
> >
> > u->v.rk = t->v.rk;
> >
> > @@ -365,7 +365,7 @@ Tree *t;
> > #endif
> >
> > {
> >
> > Tree *u;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return NULL;
> >
> > u = tnode(t->token);
> >
> > u->v.rk = t->v.rk;
> >
> > @@ -513,7 +513,7 @@ Tree *t;
> > t->down = tflatten( t->down );
> >
> > t->right = tflatten( t->right );
> >
> > if ( t->down == NULL ) return t;
> >
> > -
> >
> > +
> >
> > if ( t->token == ALT )
> >
> > {
> >
> > Tree *u;
> >
> > @@ -630,7 +630,7 @@ set *rk;
> > /* MR14 */ guess_point=p->p1;
> >
> > /* MR14 */ }
> >
> > /* MR14 */ p->guess_analysis_point=guess_point;
> >
> > -/* MR14 */ }
> >
> > +/* MR14 */ }
> >
> >
> >
> > if ( p->p2 == NULL )
> >
> > {
> >
> > @@ -691,7 +691,7 @@ set *rk_out;
> > set rk, rk2;
> >
> > int save_halt;
> >
> > RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
> >
> > -
> >
> > +
> >
> > #ifdef DBG_TRAV
> >
> > fprintf(stderr, "tRuleRef: %s\n", p->text);
> >
> > #endif
> >
> > @@ -1185,7 +1185,7 @@ int k, max_k;
> > #endif
> >
> > {
> >
> > Tree *t, *u;
> >
> > -
> >
> > +
> >
> > if ( k>max_k ) return NULL;
> >
> > if ( ftbl[k][findex[k]] == nil ) return NULL;
> >
> > t = permute(k+1, max_k);
> >
> > @@ -1195,7 +1195,7 @@ int k, max_k;
> > (findex[k])++; /* try next token at this k */
> >
> > return permute(k, max_k);
> >
> > }
> >
> > -
> >
> > +
> >
> > u = tmake(tnode(ftbl[k][findex[k]]), t, NULL);
> >
> > if ( k == max_k ) (findex[k])++;
> >
> > return u;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
> > index 8e41239f4751..ebf20b55850b 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
> > @@ -172,9 +172,9 @@ static void OutLineInfo(); /* MR14 */
> > /* MR11 a convenient place to set a break point */
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > -void MR_break(void)
> >
> > +void MR_break(void)
> >
> > #else
> >
> > -void MR_break()
> >
> > +void MR_break()
> >
> > #endif
> >
> > {
> >
> > return;
> >
> > @@ -1198,7 +1198,7 @@ int k;
> > #endif
> >
> > {
> >
> > require(t!=NULL, "genExprTreeOriginal: NULL tree");
> >
> > -
> >
> > +
> >
> > if ( t->token == ALT )
> >
> > {
> >
> > _gen("("); genExprTreeOriginal(t->down, k); _gen(")");
> >
> > @@ -1369,13 +1369,13 @@ static void genExprTree(tree,k)
> >
> >
> > #if 0
> >
> > /* MR20 THM This was probably an error.
> >
> > - The routine should probably reference that static
> >
> > + The routine should probably reference that static
> >
> > "across" and this declaration hides it.
> >
> > */
> >
> >
> >
> > int across;
> >
> > #endif
> >
> > -
> >
> > +
> >
> > require (tree != NULL,"genExprTree: tree is NULL");
> >
> > require (k > 0,"genExprTree: k <= 0");
> >
> >
> >
> > @@ -1557,7 +1557,7 @@ int *lastAltEmpty; /* MR23 */
> > *need_right_curly=0;
> >
> > *lastAltEmpty = 0; /* MR23 */
> >
> > if ( q->p2 == NULL ) /* only one alternative? Then don't need if */
> >
> > - {
> >
> > + {
> >
> > if (first_item_is_guess_block((Junction *)q->p1)!=NULL )
> >
> > {
> >
> > if (jtype != aLoopBlk && jtype != aOptBlk && jtype != aPlusBlk) {
> >
> > @@ -1575,7 +1575,7 @@ int *lastAltEmpty; /* MR23 */
> > for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
> >
> > {
> >
> > if ( alt->p2 == NULL ) /* chk for empty alt */
> >
> > - {
> >
> > + {
> >
> > Node *p = alt->p1;
> >
> > if ( p->ntype == nJunction )
> >
> > {
> >
> > @@ -1586,7 +1586,7 @@ int *lastAltEmpty; /* MR23 */
> >
> >
> > r: { A } b;
> >
> > b: B;
> >
> > -
> >
> > +
> >
> > with input "C"
> >
> >
> >
> > Before MR21 the error message would be "expecting B - found C". After MR21
> >
> > @@ -1714,7 +1714,7 @@ Junction *q;
> > while ( q!=NULL &&
> >
> > ( ( q->ntype==nAction ) ||
> >
> > ( q->ntype==nJunction &&
> >
> > - (q->jtype==Generic || q->jtype == aLoopBlk)
> >
> > + (q->jtype==Generic || q->jtype == aLoopBlk)
> >
> > )
> >
> > )
> >
> > )
> >
> > @@ -1757,7 +1757,7 @@ Junction *q;
> > r : ( (A)? B
> >
> > | C
> >
> > )*
> >
> > -
> >
> > +
> >
> > The routine analysis_point was seeing the guess block when
> >
> > it was still analyzing the loopBegin block. As a consequence,
> >
> > when it looked for the analysis_point it was processing the B, but
> >
> > @@ -1771,7 +1771,7 @@ Junction *q;
> > | +-> G C G ----------------------+ |
> >
> > | |
> >
> > +--- G G G -------------------------------------+
> >
> > -
> >
> > +
> >
> > Reported by Arpad Beszedes (beszedes@inf.u-szeged.hu).
> >
> >
> >
> > MR30 This is still more complicated. This fix caused ambiguity messages
> >
> > @@ -1890,9 +1890,9 @@ char *s;
> > };
> >
> > goto stringizeExit;
> >
> > stringizeStop:
> >
> > - *p++='.';
> >
> > - *p++='.';
> >
> > - *p++='.';
> >
> > + *p++='.';
> >
> > + *p++='.';
> >
> > + *p++='.';
> >
> > stringizeExit:
> >
> > *p=0;
> >
> > return stringizeBuf;
> >
> > @@ -2013,7 +2013,7 @@ RuleRefNode *p;
> >
> >
> > require(p!=NULL, "genRuleRef: invalid node and/or rule");
> >
> > require(p->ntype==nRuleRef, "genRuleRef: not rule reference");
> >
> > -
> >
> > +
> >
> > if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
> >
> > handler_id = p->altstart->exception_label;
> >
> >
> >
> > @@ -2276,7 +2276,7 @@ TokNode *p;
> > /* MR27 */ ast_label_in_action = list_search_cstring(r->ast_labels_in_actions,
> >
> > /* MR27 */ p->el_label);
> >
> > /* MR27 */ }
> >
> > -
> >
> > +
> >
> > OutLineInfo(output,p->line,FileStr[p->file]);
> >
> >
> >
> > if ( !set_nil(p->tset) ) /* implies '.', ~Tok, or tokenclass */
> >
> > @@ -2595,7 +2595,7 @@ TokNode *p;
> > And moved into genAction
> >
> > *****************************************************************************
> >
> > */
> >
> > -
> >
> > +
> >
> > gen("if (!(");
> >
> >
> >
> > /* make sure that '#line n' is on front of line */ /* MR14 */
> >
> > @@ -2635,12 +2635,12 @@ TokNode *p;
> > one. This is different than the case for semantic
> >
> > predicates.
> >
> > */
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (GenCC) {
> >
> > /* MR23 */ if (strstr(a->action, "LT(") != NULL) LTinTokenAction = 1;
> >
> > /* MR23 */ }
> >
> > /* MR23 */ else {
> >
> > -/* MR23 */ if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;
> >
> > +/* MR23 */ if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;
> >
> > /* MR23 */ if (strstr(a->action, "LATEXT(") != NULL) LTinTokenAction = 1;
> >
> > /* MR23 */ }
> >
> >
> >
> > @@ -2737,7 +2737,7 @@ Junction *q;
> > BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
> >
> > f = genBlk(q, aOptBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
> >
> > /* MR23
> >
> > - Bypass error clause generation when exceptions are used in {...} block
> >
> > + Bypass error clause generation when exceptions are used in {...} block
> >
> > See multi-line note in genBlk near call to isEmptyAlt.
> >
> > */
> >
> > if (! FoundException) {
> >
> > @@ -3066,7 +3066,7 @@ Junction *q;
> > BlkLevel++;
> >
> >
> >
> > BlockPreambleOption((Junction *)q, q->pFirstSetSymbol); /* MR21 */
> >
> > -
> >
> > +
> >
> > /* first_item_is_guess_block doesn't care what kind of node it is */
> >
> >
> >
> > guessBlock=first_item_is_guess_block( (Junction *)q->p1); /* MR10 */
> >
> > @@ -3280,7 +3280,7 @@ Junction *q;
> >
> >
> > /* MR23
> >
> > Bypass error clause generation when exceptions are used in a sub block
> >
> > - in which the last alternative is epsilon. Example: "(A | B | )".
> >
> > + in which the last alternative is epsilon. Example: "(A | B | )".
> >
> > See multi-line note in genBlk near call to isEmptyAlt.
> >
> > */
> >
> > if (FoundException && lastAltEmpty) {
> >
> > @@ -3289,7 +3289,7 @@ Junction *q;
> > else {
> >
> > if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
> >
> > }
> >
> > -
> >
> > +
> >
> > { int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
> >
> > freeBlkFsets(q);
> >
> > --BlkLevel;
> >
> > @@ -3403,9 +3403,9 @@ do { /* MR10 Change recursion into iteration */
> > DumpFuncHeader(q,r);
> >
> > tabs++;
> >
> >
> >
> > - /* MR23
> >
> > -
> >
> > - If there is a single return value then it can be initialized in
> >
> > + /* MR23
> >
> > +
> >
> > + If there is a single return value then it can be initialized in
> >
> > the declaration using assignment syntax. If there are multiple
> >
> > return values then antlr creates a struct and initialization takes
> >
> > place element by element for each element of the struct. For
> >
> > @@ -3419,7 +3419,7 @@ do { /* MR10 Change recursion into iteration */
> > mode because C does not have constructors. However, PURIFY is
> >
> > not used in C++ mode because it might overwrite information created
> >
> > by elements which have their own ctor.
> >
> > -
> >
> > +
> >
> > */
> >
> >
> >
> > if ( q->ret!=NULL )
> >
> > @@ -3568,7 +3568,7 @@ do { /* MR10 Change recursion into iteration */
> > FillSet( follow );
> >
> > set_free( follow );
> >
> >
> >
> > - /* MR20 G. Hobbelt
> >
> > + /* MR20 G. Hobbelt
> >
> > Isn't it so that "fail:" is ONLY referenced when:
> >
> >
> >
> > !FoundException || FoundGuessBlk ?
> >
> > @@ -3576,7 +3576,7 @@ do { /* MR10 Change recursion into iteration */
> > Therefore add the "if" around this piece of code generation...
> >
> >
> >
> > Should guessing mode also use _handler label instead of "fail"
> >
> > - when exception handling is active? gen can automatically put
> >
> > + when exception handling is active? gen can automatically put
> >
> > "if (guessing)" there so as to skip all kinds of user code.
> >
> >
> >
> > */
> >
> > @@ -4269,7 +4269,7 @@ Node *q;
> > Junction *j;
> >
> > require(q!=NULL, "findImmedAction: NULL node");
> >
> > require(q->ntype>=1 && q->ntype<=NumNodeTypes, "findImmedAction: invalid node");
> >
> > -
> >
> > +
> >
> > while ( q->ntype == nJunction )
> >
> > {
> >
> > j = (Junction *)q;
> >
> > @@ -4292,14 +4292,14 @@ RuleRefNode *ruleRefNode;
> > #endif
> >
> > {
> >
> > char *q = ret_def;
> >
> > -
> >
> > +
> >
> > tab();
> >
> > while ( *retval != '\0' && *q != '\0')
> >
> > {
> >
> > while ( isspace((*retval)) ) retval++;
> >
> > while ( *retval!=',' && *retval!='\0' ) fputc(*retval++, output);
> >
> > fprintf(output, " = _trv.");
> >
> > -
> >
> > +
> >
> > DumpNextNameInDef(&q, output);
> >
> > while ( isspace(*q) ) q++;
> >
> > fputc(';', output); fputc(' ', output);
> >
> > @@ -4440,7 +4440,7 @@ int usePlusBlockBypass;
> >
> >
> > if ( GenCC ) {_gen1(",err%d", DefErrSet( &f, 1, NULL ));}
> >
> > else _gen1(",zzerr%d", DefErrSet( &f, 1, NULL ));
> >
> > -
> >
> > +
> >
> > set_free(f);
> >
> > }
> >
> > }
> >
> > @@ -4614,12 +4614,12 @@ int final_newline;
> > ** Junction* alt1;
> >
> > ** Junction* p;
> >
> > ** set rk;
> >
> > -**
> >
> > +**
> >
> > ** require (max_k <= CLL_k, "k > CLL_k");
> >
> > -**
> >
> > -**
> >
> > +**
> >
> > +**
> >
> > ** for (k = 1; k <= CLL_k; k++) {set_clr(q->fset[k]); }
> >
> > -**
> >
> > +**
> >
> > ** for (k = 1; k <= max_k; k++) {
> >
> > ** for (alt1=q; alt1 != NULL; alt1 = (Junction *)alt1->p2)
> >
> > ** {
> >
> > @@ -4652,7 +4652,7 @@ char * pReturn;
> > int nest = 0;
> >
> > char *q;
> >
> >
> >
> > - require(pReturn!=NULL, "DumpInitializer: invalid string");
> >
> > + require(pReturn!=NULL, "DumpInitializer: invalid string");
> >
> >
> >
> > while (*p != 0) {
> >
> > p = endFormal(p,
> >
> > @@ -4692,7 +4692,7 @@ int bInitializer;
> > char *q;
> >
> > int count = 0;
> >
> >
> >
> > - require(pReturn!=NULL, "DumpFormals: invalid string");
> >
> > + require(pReturn!=NULL, "DumpFormals: invalid string");
> >
> >
> >
> > while (*p != 0) {
> >
> > p = endFormal(p,
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
> > index 30cc8b603148..bceed938f98c 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
> > @@ -277,7 +277,7 @@ typedef Graph Attrib;
> > zzenterANTLR(f); \
> >
> > st; ++zzasp; \
> >
> > zzleaveANTLR(f);
> >
> > - #endif
> >
> > + #endif
> >
> > *********************************************************/
> >
> > #endif
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
> > index 68fe8fd22768..32e939ecb20d 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
> > @@ -73,7 +73,7 @@ newHashTable( )
> > #endif
> >
> > {
> >
> > Entry **table;
> >
> > -
> >
> > +
> >
> > table = (Entry **) calloc(size, sizeof(Entry *));
> >
> > require( table != NULL, "cannot allocate hash table");
> >
> > if ( strings == NULL )
> >
> > @@ -111,7 +111,7 @@ Entry *rec;
> > unsigned h=0;
> >
> > char *p=key;
> >
> > require(table!=NULL && key!=NULL && rec!=NULL, "add: invalid addition");
> >
> > -
> >
> > +
> >
> > Hash(p,h,size);
> >
> > rec->next = table[h]; /* Add to singly-linked list */
> >
> > table[h] = rec;
> >
> > @@ -133,7 +133,7 @@ char *key;
> > Entry *q;
> >
> > /* require(table!=NULL && key!=NULL, "get: invalid table and/or key");*/
> >
> > if ( !(table!=NULL && key!=NULL) ) *((char *) 34) = 3;
> >
> > -
> >
> > +
> >
> > Hash(p,h,size);
> >
> > for (q = table[h]; q != NULL; q = q->next)
> >
> > {
> >
> > @@ -155,13 +155,13 @@ Entry **table;
> > int i,n=0,low=0, hi=0;
> >
> > Entry **p;
> >
> > float avg=0.0;
> >
> > -
> >
> > +
> >
> > for (i=0; i<20; i++) count[i] = 0;
> >
> > for (p=table; p<&(table[size]); p++)
> >
> > {
> >
> > Entry *q = *p;
> >
> > int len;
> >
> > -
> >
> > +
> >
> > if ( q != NULL && low==0 ) low = p-table;
> >
> > len = 0;
> >
> > if ( q != NULL ) fprintf(stderr, "[%d]", p-table);
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
> > index fddb46bbc398..3c530dfe5331 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
> > @@ -291,7 +291,7 @@ genDefFile( )
> > if ( TokenString(i)!=NULL && i != EpToken )
> >
> > {
> >
> > TermEntry *p;
> >
> > -
> >
> > +
> >
> > if ( WarningLevel>1 )
> >
> > {
> >
> > int j;
> >
> > @@ -491,7 +491,7 @@ Junction *p;
> > DumpRetValStruct(f, p->ret, i);
> >
> > }
> >
> > fprintf(f, "\n#ifdef __USE_PROTOS\n");
> >
> > -/* MR23 */ if ( hasMultipleOperands(p->ret) )
> >
> > +/* MR23 */ if ( hasMultipleOperands(p->ret) )
> >
> > {
> >
> > fprintf(f, "extern struct _rv%d", i);
> >
> > }
> >
> > @@ -762,7 +762,7 @@ FILE *f;
> > char *pSeparator;
> >
> > int nest = 0;
> >
> >
> >
> > - require(s!=NULL, "DumpType: invalid type string");
> >
> > + require(s!=NULL, "DumpType: invalid type string");
> >
> >
> >
> > p = endFormal(s,
> >
> > &pDataType,
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
> > index 051ee4ec5d28..be9b8c596983 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
> > @@ -799,7 +799,7 @@ char *argv[];
> > buildRulePtr(); /* create mapping from rule # to RuleBlk junction */
> >
> > ComputeErrorSets();
> >
> > FoLink( (Node *)SynDiag ); /* add follow links to end of all rules */
> >
> > -
> >
> > +
> >
> > if ( GenCR ) GenCrossRef( SynDiag );
> >
> >
> >
> > if ( CodeGen )
> >
> > @@ -955,11 +955,11 @@ char *argv[];
> > }
> >
> > cleanUp();
> >
> > exit(PCCTS_EXIT_SUCCESS);
> >
> > - return 0; /* MR11 make compilers happy */
> >
> > + return 0; /* MR11 make compilers happy */
> >
> > }
> >
> >
> >
> > -static void
> >
> > -#ifdef __USE_PROTOS
> >
> > +static void
> >
> > +#ifdef __USE_PROTOS
> >
> > init( void )
> >
> > #else
> >
> > init( )
> >
> > @@ -990,7 +990,7 @@ init( )
> > (Entry *)newSignalEntry("NoSemViableAlt"));
> >
> > require(q!=NULL, "cannot alloc signal entry");
> >
> > q->signum = sigNoSemViableAlt;
> >
> > -
> >
> > +
> >
> > reserved_positions = empty;
> >
> > all_tokens = empty;
> >
> > imag_tokens = empty;
> >
> > @@ -1041,7 +1041,7 @@ buildRulePtr( )
> > Junction *p = SynDiag;
> >
> > RulePtr = (Junction **) calloc(NumRules+1, sizeof(Junction *));
> >
> > require(RulePtr!=NULL, "cannot allocate RulePtr array");
> >
> > -
> >
> > +
> >
> > while ( p!=NULL )
> >
> > {
> >
> > require(r<=NumRules, "too many rules???");
> >
> > @@ -1224,7 +1224,7 @@ char *a3;
> > #endif
> >
> > {
> >
> > static char buf[250]; /* DANGEROUS as hell !!!!!! */
> >
> > -
> >
> > +
> >
> > sprintf(buf, s, a1, a2, a3);
> >
> > return( buf );
> >
> > }
> >
> > @@ -1240,7 +1240,7 @@ int d;
> > #endif
> >
> > {
> >
> > static char buf[250]; /* DANGEROUS as hell !!!!!! */
> >
> > -
> >
> > +
> >
> > sprintf(buf, s, d);
> >
> > return( buf );
> >
> > }
> >
> > @@ -1256,7 +1256,7 @@ int d2;
> > #endif
> >
> > {
> >
> > static char buf[250]; /* DANGEROUS as hell !!!!!! */
> >
> > -
> >
> > +
> >
> > sprintf(buf, s, d1, d2);
> >
> > return( buf );
> >
> > }
> >
> > @@ -1422,7 +1422,7 @@ exit(PCCTS_EXIT_FAILURE);
> > }
> >
> > }
> >
> >
> >
> > -static void
> >
> > +static void
> >
> > #ifdef __USE_PROTOS
> >
> > CompleteContextGuards(void)
> >
> > #else
> >
> > @@ -1507,7 +1507,7 @@ OutMetaName(char *n)
> > OutMetaName(n)
> >
> > char *n;
> >
> > #endif
> >
> > -{
> >
> > +{
> >
> > static char *dir_sym = DirectorySymbol;
> >
> > static char newname[MaxFileName+1];
> >
> > char *p;
> >
> > @@ -1607,15 +1607,15 @@ int l;
> > char *err;
> >
> > #endif
> >
> > {
> >
> > - fprintf(stderr, ErrHdr, f, l);
> >
> > + fprintf(stderr, ErrHdr, f, l);
> >
> > fprintf(stderr, " warning: %s\n", err);
> >
> > }
> >
> >
> >
> > void
> >
> > #ifdef __USE_PROTOS
> >
> > -warn(char *err)
> >
> > +warn(char *err)
> >
> > #else
> >
> > -warn(err)
> >
> > +warn(err)
> >
> > char *err;
> >
> > #endif
> >
> > {
> >
> > @@ -1629,7 +1629,7 @@ void
> > #ifdef __USE_PROTOS
> >
> > warnNoCR( char *err )
> >
> > #else
> >
> > -warnNoCR( err )
> >
> > +warnNoCR( err )
> >
> > char *err;
> >
> > #endif
> >
> > {
> >
> > @@ -1660,15 +1660,15 @@ char *f;
> > int l;
> >
> > #endif
> >
> > {
> >
> > - fprintf(stderr, ErrHdr, f, l);
> >
> > + fprintf(stderr, ErrHdr, f, l);
> >
> > fprintf(stderr, " error: %s\n", err);
> >
> > }
> >
> >
> >
> > void
> >
> > #ifdef __USE_PROTOS
> >
> > -err(char *err)
> >
> > +err(char *err)
> >
> > #else
> >
> > -err(err)
> >
> > +err(err)
> >
> > char *err;
> >
> > #endif
> >
> > {
> >
> > @@ -1680,9 +1680,9 @@ char *err;
> >
> >
> > void
> >
> > #ifdef __USE_PROTOS
> >
> > -errNoCR( char *err )
> >
> > +errNoCR( char *err )
> >
> > #else
> >
> > -errNoCR( err )
> >
> > +errNoCR( err )
> >
> > char *err;
> >
> > #endif
> >
> > {
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
> > index 8f2cc78c5947..9de355d0e646 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
> > @@ -8,7 +8,7 @@
> > # company may do whatever they wish with source code distributed with
> >
> > # PCCTS or the code generated by PCCTS, including the incorporation of
> >
> > # PCCTS, or its output, into commerical software.
> >
> > -#
> >
> > +#
> >
> > # We encourage users to develop software with PCCTS. However, we do ask
> >
> > # that credit is given to us for developing PCCTS. By "credit",
> >
> > # we mean that if you incorporate our source code into one of your
> >
> > @@ -205,7 +205,7 @@ scan.o : scan.c mode.h tokens.h
> > set.o : $(SET)/set.c
> >
> > $(BUILD_CC) $(BUILD_CFLAGS) -c -o set.o $(SET)/set.c
> >
> >
> >
> > -%.o : %.c
> >
> > +%.o : %.c
> >
> > $(BUILD_CC) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $< -o $@
> >
> >
> >
> > #
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
> > index 3f58da34c54b..abcb95260e3b 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
> > @@ -479,7 +479,7 @@ char *term;
> > {
> >
> > TermEntry *p;
> >
> > require(term!=NULL, "Tnum: invalid terminal");
> >
> > -
> >
> > +
> >
> > if ( *term=='"' ) p = (TermEntry *) hash_get(Texpr, term);
> >
> > else p = (TermEntry *) hash_get(Tname, term);
> >
> > if ( p == NULL ) return 0;
> >
> > @@ -559,14 +559,14 @@ int sz;
> > {
> >
> > Entry *p;
> >
> > require(text!=NULL, "new: NULL terminal");
> >
> > -
> >
> > +
> >
> > if ( (p = (Entry *) calloc(1,sz)) == 0 )
> >
> > {
> >
> > fatal_internal("newEntry: out of memory for terminals\n");
> >
> > exit(PCCTS_EXIT_FAILURE);
> >
> > }
> >
> > p->str = mystrdup(text);
> >
> > -
> >
> > +
> >
> > return(p);
> >
> > }
> >
> >
> >
> > @@ -671,7 +671,7 @@ int list_search_cstring(list, cstring)
> > }
> >
> >
> >
> > /* F O L L O W C y c l e S t u f f */
> >
> > -
> >
> > +
> >
> > /* make a key based upon (rulename, computation, k value).
> >
> > * Computation values are 'i'==FIRST, 'o'==FOLLOW.
> >
> > */
> >
> > @@ -692,7 +692,7 @@ int k;
> > {
> >
> > static char key[MaxRuleName+2+2+1]; /* MR10 */
> >
> > int i;
> >
> > -
> >
> > +
> >
> > if ( k > 99 ) /* MR10 */
> >
> > fatal("k>99 is too big for this implementation of ANTLR!\n"); /* MR10 */
> >
> > if ( (i=strlen(rule)) > MaxRuleName ) /* MR10 */
> >
> > @@ -839,7 +839,7 @@ int k;
> > for (p=FoTOS[k]; *p != r->rulenum && p >= FoStack[k]; --p) {;}
> >
> > require(p>=FoStack[k], "RegisterCycle: FoStack is screwed up beyond belief");
> >
> > if ( p == FoTOS[k] ) return; /* don't worry about cycles to oneself */
> >
> > -
> >
> > +
> >
> > /* compute cyclic dependents (rules in cycle except head) */
> >
> > c = newCycle;
> >
> > require(c!=NULL, "RegisterCycle: couldn't alloc new cycle");
> >
> > @@ -855,7 +855,7 @@ int k;
> > hash_add(Fcache, Fkey(RulePtr[*p]->rname,'o',k), (Entry *)f);
> >
> > }
> >
> > f->incomplete = TRUE;
> >
> > -
> >
> > +
> >
> > set_orel(*p, &(c->cyclicDep)); /* mark rule as dependent of croot */
> >
> > }
> >
> > list_add(&(Cycles[k]), (void *)c);
> >
> > @@ -890,7 +890,7 @@ int k;
> >
> >
> > unsigned *cursor; /* MR10 */
> >
> > unsigned *origin; /* MR10 */
> >
> > -
> >
> > +
> >
> > /*fprintf(stderr, "Resolving following cycles for %d\n", k);*/
> >
> > while ( changed )
> >
> > {
> >
> > @@ -1052,7 +1052,7 @@ Junction *q;
> > int doing_rule;
> >
> > require(q!=NULL, "pJunc: NULL node");
> >
> > require(q->ntype==nJunction, "pJunc: not junction");
> >
> > -
> >
> > +
> >
> > if ( q->pvisited == TRUE ) return;
> >
> > q->pvisited = TRUE;
> >
> > switch ( q->jtype )
> >
> > @@ -1177,7 +1177,7 @@ RuleRefNode *p;
> > {
> >
> > require(p!=NULL, "pRuleRef: NULL node");
> >
> > require(p->ntype==nRuleRef, "pRuleRef: not rule ref node");
> >
> > -
> >
> > +
> >
> > printf( " %s", p->text);
> >
> > PRINT(p->next);
> >
> > }
> >
> > @@ -1210,7 +1210,7 @@ ActionNode *p;
> > {
> >
> > require(p!=NULL, "pAction: NULL node");
> >
> > require(p->ntype==nAction, "pAction: not action node");
> >
> > -
> >
> > +
> >
> > PRINT(p->next);
> >
> > }
> >
> >
> >
> > @@ -1424,7 +1424,7 @@ Junction *p;
> > hand written code ?
> >
> >
> >
> > Examples of input:
> >
> > -
> >
> > +
> >
> > Foo f,
> >
> > Foo f = Foo(1),
> >
> > Foo f = Foo(1,2),
> >
> > @@ -1521,7 +1521,7 @@ int *pNest;
> > #endif
> >
> > {
> >
> > char *p = pStart;
> >
> > -
> >
> > +
> >
> > int nest = 0;
> >
> >
> >
> > *pNest = (-1);
> >
> > @@ -1544,11 +1544,11 @@ int *pNest;
> > nest--;
> >
> > p++;
> >
> > break;
> >
> > -
> >
> > +
> >
> > case '"' :
> >
> > p = skipStringLiteral(p);
> >
> > break;
> >
> > -
> >
> > +
> >
> > case '\'' :
> >
> > p = skipCharLiteral(p);
> >
> > break;
> >
> > @@ -1609,7 +1609,7 @@ char * pStart;
> > char *pSeparator;
> >
> > int nest = 0;
> >
> >
> >
> > - require(pStart!=NULL, "getInitializer: invalid string");
> >
> > + require(pStart!=NULL, "getInitializer: invalid string");
> >
> >
> >
> > p = endFormal(pStart,
> >
> > &pDataType,
> >
> > @@ -1686,7 +1686,7 @@ static char strBetweenWorkArea[MAX_STR_BETWEEN_WORK_AREA];
> > to a work area. The start of the string is pStart. The end of the string
> >
> > is the character before pNext, or if pNext is null then the character before
> >
> > pStop. Trailing spaces are not included in the copy operation.
> >
> > -
> >
> > +
> >
> > This is used when a string contains several parts. The pNext part may be
> >
> > optional. The pStop will stop the scan when the optional part is not present
> >
> > (is a null pointer).
> >
> > @@ -1740,7 +1740,7 @@ char *pStop;
> > Example: pointer to "f".
> >
> >
> >
> > ppEqualSign Returns a pointer to the equal sign separating the
> >
> > - formal symbol from the initial value. If there is
> >
> > + formal symbol from the initial value. If there is
> >
> > no "=" then this will be NULL.
> >
> >
> >
> > ppValue Returns a pointer to the initial value part of the
> >
> > @@ -1755,8 +1755,8 @@ char *pStop;
> > for a successful parse of this portion of the formal
> >
> > list.
> >
> >
> >
> > -*/
> >
> > -
> >
> > +*/
> >
> > +
> >
> > #ifdef __USE_PROTOS
> >
> > char * endFormal(char *pStart,
> >
> > char **ppDataType,
> >
> > @@ -1803,7 +1803,7 @@ int *pNest;
> > /* We are not looking for the symbol, we are looking
> >
> > for the separator that follows the symbol. Then
> >
> > we'll back up.
> >
> > -
> >
> > +
> >
> > Search for the ',' or '=" or null terminator.
> >
> > */
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
> > index b57f5ded846c..0d048dd6bf68 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
> > @@ -1026,7 +1026,7 @@ void MR_complete_tree(predDepth,t,incomplete)
> >
> >
> > rk2=empty;
> >
> >
> >
> > - while ( !set_nil(*incomplete) ) {
> >
> > + while ( !set_nil(*incomplete) ) {
> >
> > k2 = set_int(*incomplete);
> >
> > if (k2 > (unsigned) predDepth) break; /* <=== another exit from loop */
> >
> > set_rm(k2,*incomplete);
> >
> > @@ -2727,7 +2727,7 @@ int MR_suppressK_client(tree,tokensInChain)
> > /*** constrain = &(fset[1]); ***/
> >
> >
> >
> > MR_setConstrainPointer(&(fset[1])); /* MR18 */
> >
> > -
> >
> > +
> >
> > MR_pointerStackReset(&MR_BackTraceStack);
> >
> >
> >
> > TRAV(suppressNode,maxk,&incomplete,t);
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
> > index eb11c4d9504f..0ef4824ef2a6 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
> > @@ -320,7 +320,7 @@ Node *alt;
> > case nJunction :
> >
> > {
> >
> > Predicate *a, *b;
> >
> > - Junction *p = (Junction *) alt;
> >
> > + Junction *p = (Junction *) alt;
> >
> >
> >
> > /* lock nodes */
> >
> > if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
> >
> > @@ -672,7 +672,7 @@ Predicate *a;
> >
> >
> > /* any k left to do? if so, link onto tree */
> >
> > while ( !set_nil(a->completionTree) )
> >
> > - {
> >
> > + {
> >
> > k2 = set_int(a->completionTree);
> >
> > set_rm(k2, a->completionTree);
> >
> > u = NULL;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
> > index 9b4bde08e6ea..67c6aa0323bf 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
> > @@ -68,7 +68,7 @@ char *inline_set();
> >
> >
> > int tokenActionActive=0; /* MR1 */
> >
> >
> >
> > -
> >
> > +
> >
> >
> >
> >
> >
> >
> >
> > @@ -81,18 +81,18 @@ char *toStr, *fromStr;
> > #endif
> >
> > {
> >
> > int i, j, k;
> >
> > -
> >
> > +
> >
> > if (!fromStr || !toStr) return toStr;
> >
> > -
> >
> > +
> >
> > /* find the first " */
> >
> > -
> >
> > +
> >
> > for (i=0;
> >
> > (i<MaxFileName) &&
> >
> > (fromStr[i] != '\n') &&
> >
> > (fromStr[i] != '\r') &&
> >
> > (fromStr[i] != '\"');
> >
> > i++) /* nothing */ ;
> >
> > -
> >
> > +
> >
> > if ( (i == MaxFileName) ||
> >
> > (fromStr[i] == '\n') ||
> >
> > (fromStr[i] == '\r') ) {
> >
> > @@ -135,7 +135,7 @@ toStr[i-k-1] = fromStr[i];
> >
> >
> > /* MR14 end of a block to support #line in antlr source code */
> >
> >
> >
> > -
> >
> > +
> >
> >
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > @@ -153,7 +153,7 @@ LabelEntry *le;
> > }
> >
> >
> >
> > static void act1()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > /* L o o k F o r A n o t h e r F i l e */
> >
> > {
> >
> > @@ -169,362 +169,362 @@ static void act1()
> >
> >
> >
> >
> > static void act2()
> >
> > -{
> >
> > +{
> >
> > NLA = 76;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act3()
> >
> > -{
> >
> > +{
> >
> > NLA = 77;
> >
> > - zzline++; zzskip();
> >
> > + zzline++; zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act4()
> >
> > -{
> >
> > +{
> >
> > NLA = 78;
> >
> > zzmode(ACTIONS); zzmore();
> >
> > istackreset();
> >
> > - pushint(']');
> >
> > + pushint(']');
> >
> > }
> >
> >
> >
> >
> >
> > static void act5()
> >
> > -{
> >
> > +{
> >
> > NLA = 79;
> >
> > action_file=CurFile; action_line=zzline;
> >
> > zzmode(ACTIONS); zzmore();
> >
> > list_free(&CurActionLabels,0); /* MR10 */
> >
> > numericActionLabel=0; /* MR10 */
> >
> > istackreset();
> >
> > - pushint('>');
> >
> > + pushint('>');
> >
> > }
> >
> >
> >
> >
> >
> > static void act6()
> >
> > -{
> >
> > +{
> >
> > NLA = 80;
> >
> > - zzmode(STRINGS); zzmore();
> >
> > + zzmode(STRINGS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act7()
> >
> > -{
> >
> > +{
> >
> > NLA = 81;
> >
> > - zzmode(COMMENTS); zzskip();
> >
> > + zzmode(COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act8()
> >
> > -{
> >
> > +{
> >
> > NLA = 82;
> >
> > - warn("Missing /*; found dangling */"); zzskip();
> >
> > + warn("Missing /*; found dangling */"); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act9()
> >
> > -{
> >
> > +{
> >
> > NLA = 83;
> >
> > - zzmode(CPP_COMMENTS); zzskip();
> >
> > + zzmode(CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act10()
> >
> > -{
> >
> > +{
> >
> > NLA = 84;
> >
> > -
> >
> > +
> >
> > zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
> >
> > getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
> >
> > }
> >
> >
> >
> >
> >
> > static void act11()
> >
> > -{
> >
> > +{
> >
> > NLA = 85;
> >
> > -
> >
> > +
> >
> > zzline++; zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act12()
> >
> > -{
> >
> > +{
> >
> > NLA = 86;
> >
> > - warn("Missing <<; found dangling >>"); zzskip();
> >
> > + warn("Missing <<; found dangling >>"); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act13()
> >
> > -{
> >
> > +{
> >
> > NLA = WildCard;
> >
> > }
> >
> >
> >
> >
> >
> > static void act14()
> >
> > -{
> >
> > +{
> >
> > NLA = 88;
> >
> > FoundException = 1; /* MR6 */
> >
> > - FoundAtOperator = 1;
> >
> > + FoundAtOperator = 1;
> >
> > }
> >
> >
> >
> >
> >
> > static void act15()
> >
> > -{
> >
> > +{
> >
> > NLA = Pragma;
> >
> > }
> >
> >
> >
> >
> >
> > static void act16()
> >
> > -{
> >
> > +{
> >
> > NLA = FirstSetSymbol;
> >
> > }
> >
> >
> >
> >
> >
> > static void act17()
> >
> > -{
> >
> > +{
> >
> > NLA = 94;
> >
> > }
> >
> >
> >
> >
> >
> > static void act18()
> >
> > -{
> >
> > +{
> >
> > NLA = 95;
> >
> > }
> >
> >
> >
> >
> >
> > static void act19()
> >
> > -{
> >
> > +{
> >
> > NLA = 96;
> >
> > }
> >
> >
> >
> >
> >
> > static void act20()
> >
> > -{
> >
> > +{
> >
> > NLA = 97;
> >
> > }
> >
> >
> >
> >
> >
> > static void act21()
> >
> > -{
> >
> > +{
> >
> > NLA = 98;
> >
> > }
> >
> >
> >
> >
> >
> > static void act22()
> >
> > -{
> >
> > +{
> >
> > NLA = 99;
> >
> > }
> >
> >
> >
> >
> >
> > static void act23()
> >
> > -{
> >
> > +{
> >
> > NLA = 102;
> >
> > }
> >
> >
> >
> >
> >
> > static void act24()
> >
> > -{
> >
> > +{
> >
> > NLA = 103;
> >
> > }
> >
> >
> >
> >
> >
> > static void act25()
> >
> > -{
> >
> > +{
> >
> > NLA = 104;
> >
> > }
> >
> >
> >
> >
> >
> > static void act26()
> >
> > -{
> >
> > +{
> >
> > NLA = 105;
> >
> > }
> >
> >
> >
> >
> >
> > static void act27()
> >
> > -{
> >
> > +{
> >
> > NLA = 106;
> >
> > }
> >
> >
> >
> >
> >
> > static void act28()
> >
> > -{
> >
> > +{
> >
> > NLA = 107;
> >
> > }
> >
> >
> >
> >
> >
> > static void act29()
> >
> > -{
> >
> > +{
> >
> > NLA = 108;
> >
> > }
> >
> >
> >
> >
> >
> > static void act30()
> >
> > -{
> >
> > +{
> >
> > NLA = 109;
> >
> > }
> >
> >
> >
> >
> >
> > static void act31()
> >
> > -{
> >
> > +{
> >
> > NLA = 110;
> >
> > }
> >
> >
> >
> >
> >
> > static void act32()
> >
> > -{
> >
> > +{
> >
> > NLA = 111;
> >
> > }
> >
> >
> >
> >
> >
> > static void act33()
> >
> > -{
> >
> > +{
> >
> > NLA = 112;
> >
> > }
> >
> >
> >
> >
> >
> > static void act34()
> >
> > -{
> >
> > +{
> >
> > NLA = 113;
> >
> > }
> >
> >
> >
> >
> >
> > static void act35()
> >
> > -{
> >
> > +{
> >
> > NLA = 114;
> >
> > }
> >
> >
> >
> >
> >
> > static void act36()
> >
> > -{
> >
> > +{
> >
> > NLA = 115;
> >
> > }
> >
> >
> >
> >
> >
> > static void act37()
> >
> > -{
> >
> > +{
> >
> > NLA = 116;
> >
> > }
> >
> >
> >
> >
> >
> > static void act38()
> >
> > -{
> >
> > +{
> >
> > NLA = 117;
> >
> > }
> >
> >
> >
> >
> >
> > static void act39()
> >
> > -{
> >
> > +{
> >
> > NLA = 118;
> >
> > }
> >
> >
> >
> >
> >
> > static void act40()
> >
> > -{
> >
> > +{
> >
> > NLA = 119;
> >
> > }
> >
> >
> >
> >
> >
> > static void act41()
> >
> > -{
> >
> > +{
> >
> > NLA = 120;
> >
> > }
> >
> >
> >
> >
> >
> > static void act42()
> >
> > -{
> >
> > +{
> >
> > NLA = 121;
> >
> > }
> >
> >
> >
> >
> >
> > static void act43()
> >
> > -{
> >
> > +{
> >
> > NLA = 122;
> >
> > }
> >
> >
> >
> >
> >
> > static void act44()
> >
> > -{
> >
> > +{
> >
> > NLA = 123;
> >
> > }
> >
> >
> >
> >
> >
> > static void act45()
> >
> > -{
> >
> > +{
> >
> > NLA = 124;
> >
> > }
> >
> >
> >
> >
> >
> > static void act46()
> >
> > -{
> >
> > +{
> >
> > NLA = 125;
> >
> > }
> >
> >
> >
> >
> >
> > static void act47()
> >
> > -{
> >
> > +{
> >
> > NLA = 126;
> >
> > }
> >
> >
> >
> >
> >
> > static void act48()
> >
> > -{
> >
> > +{
> >
> > NLA = 127;
> >
> > }
> >
> >
> >
> >
> >
> > static void act49()
> >
> > -{
> >
> > +{
> >
> > NLA = 128;
> >
> > }
> >
> >
> >
> >
> >
> > static void act50()
> >
> > -{
> >
> > +{
> >
> > NLA = 129;
> >
> > }
> >
> >
> >
> >
> >
> > static void act51()
> >
> > -{
> >
> > +{
> >
> > NLA = 130;
> >
> > }
> >
> >
> >
> >
> >
> > static void act52()
> >
> > -{
> >
> > +{
> >
> > NLA = 131;
> >
> > }
> >
> >
> >
> >
> >
> > static void act53()
> >
> > -{
> >
> > +{
> >
> > NLA = 132;
> >
> > }
> >
> >
> >
> >
> >
> > static void act54()
> >
> > -{
> >
> > +{
> >
> > NLA = 133;
> >
> > }
> >
> >
> >
> >
> >
> > static void act55()
> >
> > -{
> >
> > +{
> >
> > NLA = 134;
> >
> > }
> >
> >
> >
> >
> >
> > static void act56()
> >
> > -{
> >
> > +{
> >
> > NLA = 135;
> >
> > }
> >
> >
> >
> >
> >
> > static void act57()
> >
> > -{
> >
> > +{
> >
> > NLA = NonTerminal;
> >
> > -
> >
> > +
> >
> > while ( zzchar==' ' || zzchar=='\t' ) {
> >
> > zzadvance();
> >
> > }
> >
> > @@ -533,9 +533,9 @@ static void act57()
> >
> >
> >
> >
> > static void act58()
> >
> > -{
> >
> > +{
> >
> > NLA = TokenTerm;
> >
> > -
> >
> > +
> >
> > while ( zzchar==' ' || zzchar=='\t' ) {
> >
> > zzadvance();
> >
> > }
> >
> > @@ -544,58 +544,58 @@ static void act58()
> >
> >
> >
> >
> > static void act59()
> >
> > -{
> >
> > +{
> >
> > NLA = 136;
> >
> > - warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
> >
> > + warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift0[257] = {
> >
> > - 0, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 1, 2, 58, 58, 3, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 1, 40, 6, 9, 58, 58, 45,
> >
> > - 58, 46, 47, 8, 52, 58, 58, 18, 7, 16,
> >
> > - 14, 15, 16, 16, 16, 16, 16, 16, 16, 41,
> >
> > - 42, 5, 48, 17, 53, 19, 56, 56, 56, 56,
> >
> > - 56, 26, 56, 56, 56, 56, 56, 51, 56, 56,
> >
> > - 56, 56, 56, 56, 29, 56, 56, 56, 56, 56,
> >
> > - 56, 56, 4, 20, 58, 50, 57, 58, 23, 31,
> >
> > - 38, 34, 13, 35, 24, 33, 11, 55, 36, 10,
> >
> > - 25, 12, 32, 21, 55, 22, 27, 28, 54, 55,
> >
> > - 55, 43, 30, 55, 39, 44, 37, 49, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > - 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 0, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 1, 2, 58, 58, 3, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 1, 40, 6, 9, 58, 58, 45,
> >
> > + 58, 46, 47, 8, 52, 58, 58, 18, 7, 16,
> >
> > + 14, 15, 16, 16, 16, 16, 16, 16, 16, 41,
> >
> > + 42, 5, 48, 17, 53, 19, 56, 56, 56, 56,
> >
> > + 56, 26, 56, 56, 56, 56, 56, 51, 56, 56,
> >
> > + 56, 56, 56, 56, 29, 56, 56, 56, 56, 56,
> >
> > + 56, 56, 4, 20, 58, 50, 57, 58, 23, 31,
> >
> > + 38, 34, 13, 35, 24, 33, 11, 55, 36, 10,
> >
> > + 25, 12, 32, 21, 55, 22, 27, 28, 54, 55,
> >
> > + 55, 43, 30, 55, 39, 44, 37, 49, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
> >
> > 58, 58, 58, 58, 58, 58, 58
> >
> > };
> >
> >
> >
> >
> >
> > static void act60()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act61()
> >
> > -{
> >
> > +{
> >
> > NLA = QuotedTerm;
> >
> > - zzmode(START);
> >
> > + zzmode(START);
> >
> > }
> >
> >
> >
> >
> >
> > static void act62()
> >
> > -{
> >
> > +{
> >
> > NLA = 3;
> >
> > -
> >
> > +
> >
> > zzline++;
> >
> > warn("eoln found in string");
> >
> > zzskip();
> >
> > @@ -603,72 +603,72 @@ static void act62()
> >
> >
> >
> >
> > static void act63()
> >
> > -{
> >
> > +{
> >
> > NLA = 4;
> >
> > - zzline++; zzmore();
> >
> > + zzline++; zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act64()
> >
> > -{
> >
> > +{
> >
> > NLA = 5;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act65()
> >
> > -{
> >
> > +{
> >
> > NLA = 6;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift1[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act66()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act67()
> >
> > -{
> >
> > +{
> >
> > NLA = 7;
> >
> > - zzmode(ACTIONS); zzmore();
> >
> > + zzmode(ACTIONS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act68()
> >
> > -{
> >
> > +{
> >
> > NLA = 8;
> >
> > -
> >
> > +
> >
> > zzline++;
> >
> > warn("eoln found in string (in user action)");
> >
> > zzskip();
> >
> > @@ -676,72 +676,72 @@ static void act68()
> >
> >
> >
> >
> > static void act69()
> >
> > -{
> >
> > +{
> >
> > NLA = 9;
> >
> > - zzline++; zzmore();
> >
> > + zzline++; zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act70()
> >
> > -{
> >
> > +{
> >
> > NLA = 10;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act71()
> >
> > -{
> >
> > +{
> >
> > NLA = 11;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift2[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act72()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act73()
> >
> > -{
> >
> > +{
> >
> > NLA = 12;
> >
> > - zzmode(ACTIONS); zzmore();
> >
> > + zzmode(ACTIONS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act74()
> >
> > -{
> >
> > +{
> >
> > NLA = 13;
> >
> > -
> >
> > +
> >
> > zzline++;
> >
> > warn("eoln found in char literal (in user action)");
> >
> > zzskip();
> >
> > @@ -749,393 +749,393 @@ static void act74()
> >
> >
> >
> >
> > static void act75()
> >
> > -{
> >
> > +{
> >
> > NLA = 14;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act76()
> >
> > -{
> >
> > +{
> >
> > NLA = 15;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift3[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act77()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act78()
> >
> > -{
> >
> > +{
> >
> > NLA = 16;
> >
> > - zzmode(ACTIONS); zzmore();
> >
> > + zzmode(ACTIONS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act79()
> >
> > -{
> >
> > +{
> >
> > NLA = 17;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act80()
> >
> > -{
> >
> > +{
> >
> > NLA = 18;
> >
> > - zzline++; zzmore(); DAWDLE;
> >
> > + zzline++; zzmore(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act81()
> >
> > -{
> >
> > +{
> >
> > NLA = 19;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift4[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act82()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act83()
> >
> > -{
> >
> > +{
> >
> > NLA = 20;
> >
> > zzmode(PARSE_ENUM_FILE);
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act84()
> >
> > -{
> >
> > +{
> >
> > NLA = 21;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act85()
> >
> > -{
> >
> > +{
> >
> > NLA = 22;
> >
> > - zzline++; zzmore(); DAWDLE;
> >
> > + zzline++; zzmore(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act86()
> >
> > -{
> >
> > +{
> >
> > NLA = 23;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift5[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act87()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act88()
> >
> > -{
> >
> > +{
> >
> > NLA = 24;
> >
> > - zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
> >
> > + zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act89()
> >
> > -{
> >
> > +{
> >
> > NLA = 25;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift6[257] = {
> >
> > - 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > 3, 3, 3, 3, 3, 3, 3
> >
> > };
> >
> >
> >
> >
> >
> > static void act90()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act91()
> >
> > -{
> >
> > +{
> >
> > NLA = 26;
> >
> > - zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
> >
> > + zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act92()
> >
> > -{
> >
> > +{
> >
> > NLA = 27;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift7[257] = {
> >
> > - 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > 3, 3, 3, 3, 3, 3, 3
> >
> > };
> >
> >
> >
> >
> >
> > static void act93()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act94()
> >
> > -{
> >
> > +{
> >
> > NLA = 28;
> >
> > - zzline++; zzmode(START); zzskip(); DAWDLE;
> >
> > + zzline++; zzmode(START); zzskip(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act95()
> >
> > -{
> >
> > +{
> >
> > NLA = 29;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift8[257] = {
> >
> > - 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
> >
> > 3, 3, 3, 3, 3, 3, 3
> >
> > };
> >
> >
> >
> >
> >
> > static void act96()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act97()
> >
> > -{
> >
> > +{
> >
> > NLA = 30;
> >
> > - zzmode(START); zzskip();
> >
> > + zzmode(START); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act98()
> >
> > -{
> >
> > +{
> >
> > NLA = 31;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act99()
> >
> > -{
> >
> > +{
> >
> > NLA = 32;
> >
> > - zzline++; zzskip(); DAWDLE;
> >
> > + zzline++; zzskip(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act100()
> >
> > -{
> >
> > +{
> >
> > NLA = 33;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift9[257] = {
> >
> > - 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
> >
> > 5, 5, 5, 5, 5, 5, 5
> >
> > };
> >
> >
> >
> >
> >
> > static void act101()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > }
> >
> >
> >
> >
> >
> > static void act102()
> >
> > -{
> >
> > +{
> >
> > NLA = Action;
> >
> > /* these do not nest */
> >
> > zzmode(START);
> >
> > @@ -1146,17 +1146,17 @@ static void act102()
> > if ( zzbufovf ) {
> >
> > err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
> >
> > }
> >
> > -
> >
> > +
> >
> > /* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
> >
> > /* MR1 in DLG action */
> >
> > /* MR1 Doesn't matter what kind of action it is - reset*/
> >
> > -
> >
> > +
> >
> > tokenActionActive=0; /* MR1 */
> >
> > }
> >
> >
> >
> >
> >
> > static void act103()
> >
> > -{
> >
> > +{
> >
> > NLA = Pred;
> >
> > /* these do not nest */
> >
> > zzmode(START);
> >
> > @@ -1183,7 +1183,7 @@ static void act103()
> >
> >
> >
> >
> > static void act104()
> >
> > -{
> >
> > +{
> >
> > NLA = PassAction;
> >
> > if ( topint() == ']' ) {
> >
> > popint();
> >
> > @@ -1212,9 +1212,9 @@ static void act104()
> >
> >
> >
> >
> > static void act105()
> >
> > -{
> >
> > +{
> >
> > NLA = 37;
> >
> > -
> >
> > +
> >
> > zzmore();
> >
> > zzreplstr(inline_set(zzbegexpr+
> >
> > strlen("consumeUntil(")));
> >
> > @@ -1222,53 +1222,53 @@ static void act105()
> >
> >
> >
> >
> > static void act106()
> >
> > -{
> >
> > +{
> >
> > NLA = 38;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act107()
> >
> > -{
> >
> > +{
> >
> > NLA = 39;
> >
> > - zzline++; zzmore(); DAWDLE;
> >
> > + zzline++; zzmore(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act108()
> >
> > -{
> >
> > +{
> >
> > NLA = 40;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act109()
> >
> > -{
> >
> > +{
> >
> > NLA = 41;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act110()
> >
> > -{
> >
> > +{
> >
> > NLA = 42;
> >
> > if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
> >
> > - else err("$$ use invalid in C++ mode");
> >
> > + else err("$$ use invalid in C++ mode");
> >
> > }
> >
> >
> >
> >
> >
> > static void act111()
> >
> > -{
> >
> > +{
> >
> > NLA = 43;
> >
> > if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
> >
> > - else err("$[] use invalid in C++ mode");
> >
> > + else err("$[] use invalid in C++ mode");
> >
> > }
> >
> >
> >
> >
> >
> > static void act112()
> >
> > -{
> >
> > +{
> >
> > NLA = 44;
> >
> > -
> >
> > +
> >
> > pushint(']');
> >
> > if ( !GenCC ) zzreplstr("zzconstr_attr(");
> >
> > else err("$[..] use invalid in C++ mode");
> >
> > @@ -1277,7 +1277,7 @@ static void act112()
> >
> >
> >
> >
> > static void act113()
> >
> > -{
> >
> > +{
> >
> > NLA = 45;
> >
> > {
> >
> > static char buf[100];
> >
> > @@ -1299,7 +1299,7 @@ static void act113()
> >
> >
> >
> >
> > static void act114()
> >
> > -{
> >
> > +{
> >
> > NLA = 46;
> >
> > {
> >
> > static char buf[100];
> >
> > @@ -1322,7 +1322,7 @@ static void act114()
> >
> >
> >
> >
> > static void act115()
> >
> > -{
> >
> > +{
> >
> > NLA = 47;
> >
> > {
> >
> > static char buf[100];
> >
> > @@ -1356,7 +1356,7 @@ static void act115()
> >
> >
> >
> >
> > static void act116()
> >
> > -{
> >
> > +{
> >
> > NLA = 48;
> >
> > { static char buf[300]; LabelEntry *el;
> >
> > zzbegexpr[0] = ' ';
> >
> > @@ -1408,14 +1408,14 @@ zzmore();
> >
> >
> >
> >
> > static void act117()
> >
> > -{
> >
> > +{
> >
> > NLA = 49;
> >
> > - zzreplstr("(*_root)"); zzmore(); chkGTFlag();
> >
> > + zzreplstr("(*_root)"); zzmore(); chkGTFlag();
> >
> > }
> >
> >
> >
> >
> >
> > static void act118()
> >
> > -{
> >
> > +{
> >
> > NLA = 50;
> >
> > if ( GenCC ) {
> >
> > if (NewAST) zzreplstr("(newAST)");
> >
> > @@ -1426,14 +1426,14 @@ static void act118()
> >
> >
> >
> >
> > static void act119()
> >
> > -{
> >
> > +{
> >
> > NLA = 51;
> >
> > - zzreplstr("NULL"); zzmore(); chkGTFlag();
> >
> > + zzreplstr("NULL"); zzmore(); chkGTFlag();
> >
> > }
> >
> >
> >
> >
> >
> > static void act120()
> >
> > -{
> >
> > +{
> >
> > NLA = 52;
> >
> > {
> >
> > static char buf[100];
> >
> > @@ -1450,26 +1450,26 @@ static void act120()
> >
> >
> >
> >
> > static void act121()
> >
> > -{
> >
> > +{
> >
> > NLA = 53;
> >
> > -
> >
> > +
> >
> > zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
> >
> > getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
> >
> > }
> >
> >
> >
> >
> >
> > static void act122()
> >
> > -{
> >
> > +{
> >
> > NLA = 54;
> >
> > -
> >
> > +
> >
> > zzline++; zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act123()
> >
> > -{
> >
> > +{
> >
> > NLA = 55;
> >
> > -
> >
> > +
> >
> > if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
> >
> > strcmp(zzbegexpr, "#if")==0 ||
> >
> > strcmp(zzbegexpr, "#else")==0 ||
> >
> > @@ -1494,9 +1494,9 @@ static void act123()
> >
> >
> >
> >
> > static void act124()
> >
> > -{
> >
> > +{
> >
> > NLA = 56;
> >
> > -
> >
> > +
> >
> > pushint(']');
> >
> > if ( GenCC ) {
> >
> > if (NewAST) zzreplstr("(newAST(");
> >
> > @@ -1508,9 +1508,9 @@ static void act124()
> >
> >
> >
> >
> > static void act125()
> >
> > -{
> >
> > +{
> >
> > NLA = 57;
> >
> > -
> >
> > +
> >
> > pushint('}');
> >
> > if ( GenCC ) {
> >
> > if (tmakeInParser) {
> >
> > @@ -1529,16 +1529,16 @@ static void act125()
> >
> >
> >
> >
> > static void act126()
> >
> > -{
> >
> > +{
> >
> > NLA = 58;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act127()
> >
> > -{
> >
> > +{
> >
> > NLA = 59;
> >
> > -
> >
> > +
> >
> > if ( istackempty() )
> >
> > zzmore();
> >
> > else if ( topint()==')' ) {
> >
> > @@ -1554,39 +1554,39 @@ static void act127()
> >
> >
> >
> >
> > static void act128()
> >
> > -{
> >
> > +{
> >
> > NLA = 60;
> >
> > -
> >
> > +
> >
> > pushint('|'); /* look for '|' to terminate simple [...] */
> >
> > zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act129()
> >
> > -{
> >
> > +{
> >
> > NLA = 61;
> >
> > -
> >
> > +
> >
> > pushint(')');
> >
> > zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act130()
> >
> > -{
> >
> > +{
> >
> > NLA = 62;
> >
> > - zzreplstr("]"); zzmore();
> >
> > + zzreplstr("]"); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act131()
> >
> > -{
> >
> > +{
> >
> > NLA = 63;
> >
> > - zzreplstr(")"); zzmore();
> >
> > + zzreplstr(")"); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act132()
> >
> > -{
> >
> > +{
> >
> > NLA = 64;
> >
> > if (! tokenActionActive) zzreplstr(">"); /* MR1 */
> >
> > zzmore(); /* MR1 */
> >
> > @@ -1594,274 +1594,274 @@ static void act132()
> >
> >
> >
> >
> > static void act133()
> >
> > -{
> >
> > +{
> >
> > NLA = 65;
> >
> > - zzmode(ACTION_CHARS); zzmore();
> >
> > + zzmode(ACTION_CHARS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act134()
> >
> > -{
> >
> > +{
> >
> > NLA = 66;
> >
> > - zzmode(ACTION_STRINGS); zzmore();
> >
> > + zzmode(ACTION_STRINGS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act135()
> >
> > -{
> >
> > +{
> >
> > NLA = 67;
> >
> > - zzreplstr("$"); zzmore();
> >
> > + zzreplstr("$"); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act136()
> >
> > -{
> >
> > +{
> >
> > NLA = 68;
> >
> > - zzreplstr("#"); zzmore();
> >
> > + zzreplstr("#"); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act137()
> >
> > -{
> >
> > +{
> >
> > NLA = 69;
> >
> > - zzline++; zzmore();
> >
> > + zzline++; zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act138()
> >
> > -{
> >
> > +{
> >
> > NLA = 70;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act139()
> >
> > -{
> >
> > +{
> >
> > NLA = 71;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act140()
> >
> > -{
> >
> > +{
> >
> > NLA = 72;
> >
> > - zzmode(ACTION_COMMENTS); zzmore();
> >
> > + zzmode(ACTION_COMMENTS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act141()
> >
> > -{
> >
> > +{
> >
> > NLA = 73;
> >
> > - warn("Missing /*; found dangling */ in action"); zzmore();
> >
> > + warn("Missing /*; found dangling */ in action"); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act142()
> >
> > -{
> >
> > +{
> >
> > NLA = 74;
> >
> > - zzmode(ACTION_CPP_COMMENTS); zzmore();
> >
> > + zzmode(ACTION_CPP_COMMENTS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act143()
> >
> > -{
> >
> > +{
> >
> > NLA = 75;
> >
> > - zzmore();
> >
> > + zzmore();
> >
> > }
> >
> >
> >
> > static unsigned char shift10[257] = {
> >
> > - 0, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 16, 19, 33, 33, 20, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 16, 33, 28, 27, 21, 33, 33,
> >
> > - 30, 15, 18, 32, 33, 33, 33, 25, 31, 23,
> >
> > - 24, 24, 24, 24, 24, 24, 24, 24, 24, 33,
> >
> > - 33, 33, 33, 1, 2, 33, 26, 26, 26, 26,
> >
> > - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > - 26, 26, 26, 26, 26, 26, 11, 26, 26, 26,
> >
> > - 26, 26, 22, 29, 3, 33, 26, 33, 26, 26,
> >
> > - 4, 26, 10, 26, 26, 26, 13, 26, 26, 14,
> >
> > - 9, 6, 5, 26, 26, 26, 7, 12, 8, 26,
> >
> > - 26, 26, 26, 26, 17, 33, 34, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 0, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 16, 19, 33, 33, 20, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 16, 33, 28, 27, 21, 33, 33,
> >
> > + 30, 15, 18, 32, 33, 33, 33, 25, 31, 23,
> >
> > + 24, 24, 24, 24, 24, 24, 24, 24, 24, 33,
> >
> > + 33, 33, 33, 1, 2, 33, 26, 26, 26, 26,
> >
> > + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > + 26, 26, 26, 26, 26, 26, 11, 26, 26, 26,
> >
> > + 26, 26, 22, 29, 3, 33, 26, 33, 26, 26,
> >
> > + 4, 26, 10, 26, 26, 26, 13, 26, 26, 14,
> >
> > + 9, 6, 5, 26, 26, 26, 7, 12, 8, 26,
> >
> > + 26, 26, 26, 26, 17, 33, 34, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > 33, 33, 33, 33, 33, 33, 33
> >
> > };
> >
> >
> >
> >
> >
> > static void act144()
> >
> > -{
> >
> > +{
> >
> > NLA = Eof;
> >
> > - ;
> >
> > + ;
> >
> > }
> >
> >
> >
> >
> >
> > static void act145()
> >
> > -{
> >
> > +{
> >
> > NLA = 137;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act146()
> >
> > -{
> >
> > +{
> >
> > NLA = 138;
> >
> > - zzline++; zzskip();
> >
> > + zzline++; zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act147()
> >
> > -{
> >
> > +{
> >
> > NLA = 139;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
> >
> > }
> >
> >
> >
> >
> >
> > static void act148()
> >
> > -{
> >
> > +{
> >
> > NLA = 140;
> >
> > - zzmode(TOK_DEF_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act149()
> >
> > -{
> >
> > +{
> >
> > NLA = 141;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act150()
> >
> > -{
> >
> > +{
> >
> > NLA = 142;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act151()
> >
> > -{
> >
> > +{
> >
> > NLA = 143;
> >
> > - ;
> >
> > + ;
> >
> > }
> >
> >
> >
> >
> >
> > static void act152()
> >
> > -{
> >
> > +{
> >
> > NLA = 144;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act153()
> >
> > -{
> >
> > +{
> >
> > NLA = 145;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act154()
> >
> > -{
> >
> > +{
> >
> > NLA = 146;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act155()
> >
> > -{
> >
> > +{
> >
> > NLA = 147;
> >
> > - zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > + zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act156()
> >
> > -{
> >
> > +{
> >
> > NLA = 149;
> >
> > }
> >
> >
> >
> >
> >
> > static void act157()
> >
> > -{
> >
> > +{
> >
> > NLA = 151;
> >
> > }
> >
> >
> >
> >
> >
> > static void act158()
> >
> > -{
> >
> > +{
> >
> > NLA = 152;
> >
> > }
> >
> >
> >
> >
> >
> > static void act159()
> >
> > -{
> >
> > +{
> >
> > NLA = 153;
> >
> > }
> >
> >
> >
> >
> >
> > static void act160()
> >
> > -{
> >
> > +{
> >
> > NLA = 154;
> >
> > }
> >
> >
> >
> >
> >
> > static void act161()
> >
> > -{
> >
> > +{
> >
> > NLA = 155;
> >
> > }
> >
> >
> >
> >
> >
> > static void act162()
> >
> > -{
> >
> > +{
> >
> > NLA = 156;
> >
> > }
> >
> >
> >
> >
> >
> > static void act163()
> >
> > -{
> >
> > +{
> >
> > NLA = INT;
> >
> > }
> >
> >
> >
> >
> >
> > static void act164()
> >
> > -{
> >
> > +{
> >
> > NLA = ID;
> >
> > }
> >
> >
> >
> > static unsigned char shift11[257] = {
> >
> > - 0, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 1, 2, 27, 27, 3, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 1, 27, 27, 6, 27, 27, 27,
> >
> > - 27, 27, 27, 5, 27, 22, 27, 27, 4, 25,
> >
> > - 25, 25, 25, 25, 25, 25, 25, 25, 25, 27,
> >
> > - 24, 27, 21, 27, 27, 27, 26, 26, 26, 26,
> >
> > - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > - 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > - 26, 26, 27, 27, 27, 27, 26, 27, 26, 26,
> >
> > - 26, 9, 10, 8, 26, 26, 7, 26, 26, 12,
> >
> > - 15, 11, 17, 16, 26, 18, 13, 19, 14, 26,
> >
> > - 26, 26, 26, 26, 20, 27, 23, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > - 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 0, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 1, 2, 27, 27, 3, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 1, 27, 27, 6, 27, 27, 27,
> >
> > + 27, 27, 27, 5, 27, 22, 27, 27, 4, 25,
> >
> > + 25, 25, 25, 25, 25, 25, 25, 25, 25, 27,
> >
> > + 24, 27, 21, 27, 27, 27, 26, 26, 26, 26,
> >
> > + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
> >
> > + 26, 26, 27, 27, 27, 27, 26, 27, 26, 26,
> >
> > + 26, 9, 10, 8, 26, 26, 7, 26, 26, 12,
> >
> > + 15, 11, 17, 16, 26, 18, 13, 19, 14, 26,
> >
> > + 26, 26, 26, 26, 20, 27, 23, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
> >
> > 27, 27, 27, 27, 27, 27, 27
> >
> > };
> >
> >
> >
> > @@ -1869,1811 +1869,1811 @@ static unsigned char shift11[257] = {
> > typedef unsigned short DfaState;
> >
> >
> >
> > static DfaState st0[60] = {
> >
> > - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
> >
> > - 11, 11, 11, 12, 13, 13, 13, 14, 15, 16,
> >
> > - 17, 11, 11, 18, 11, 11, 19, 11, 11, 19,
> >
> > - 11, 11, 11, 11, 20, 11, 11, 21, 22, 23,
> >
> > - 24, 25, 26, 11, 27, 28, 29, 30, 31, 32,
> >
> > + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
> >
> > + 11, 11, 11, 12, 13, 13, 13, 14, 15, 16,
> >
> > + 17, 11, 11, 18, 11, 11, 19, 11, 11, 19,
> >
> > + 11, 11, 11, 11, 20, 11, 11, 21, 22, 23,
> >
> > + 24, 25, 26, 11, 27, 28, 29, 30, 31, 32,
> >
> > 33, 34, 35, 36, 11, 11, 19, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st1[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st2[60] = {
> >
> > - 436, 2, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 2, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st3[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st4[60] = {
> >
> > - 436, 436, 37, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 37, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st5[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st6[60] = {
> >
> > - 436, 436, 436, 436, 436, 38, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 38, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st7[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st8[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 39, 40, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 39, 40, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st9[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 41, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 41, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st10[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 42, 43, 43, 44, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
> >
> > - 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 42, 43, 43, 44, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
> >
> > + 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st11[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st12[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 51, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 51, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st13[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 13, 13, 13, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 13, 13, 13, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st14[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 52, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 52, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st15[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 53, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 53, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st16[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st17[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 54,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 54,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st18[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 55, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 55, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st19[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > - 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > - 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > + 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > + 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st20[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 57, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 57, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st21[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st22[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 58, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 59, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 58, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 59, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st23[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st24[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st25[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st26[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st27[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 60, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 60, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st28[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 61, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 61, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st29[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st30[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st31[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 62, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 62, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st32[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st33[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st34[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > - 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > - 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > + 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > + 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > 436, 63, 436, 436, 56, 56, 56, 56, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st35[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st36[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st37[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st38[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st39[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st40[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st41[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st42[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 64, 43, 65, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 64, 43, 65, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st43[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st44[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 66, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 66, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st45[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 67, 68, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 67, 68, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st46[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 69, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 69, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st47[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 70, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 70, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st48[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 71, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 71, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st49[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 72, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 72, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st50[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st51[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 73, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 73, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st52[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st53[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st54[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 74, 43, 43, 44, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
> >
> > - 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 74, 43, 43, 44, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
> >
> > + 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st55[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 75, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 75, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st56[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > - 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > - 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > + 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > + 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
> >
> > 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st57[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 76, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 76, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st58[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 77, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 77, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st59[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 78, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 78, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st60[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st61[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st62[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st63[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > - 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > - 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > - 436, 436, 436, 56, 436, 436, 79, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
> >
> > + 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
> >
> > + 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
> >
> > + 436, 436, 436, 56, 436, 436, 79, 436, 436, 436,
> >
> > 436, 56, 436, 436, 56, 56, 56, 56, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st64[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 80, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 80, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st65[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 81, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 81, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st66[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 82, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 82, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st67[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 83, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 84, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 83, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 84, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st68[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 85, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 85, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st69[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 86, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 86, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st70[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 87, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 87, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st71[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 88, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 88, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st72[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 89, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 89, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st73[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 90, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 90, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st74[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 65, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 65, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st75[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 91, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 91, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st76[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 92, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 92, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st77[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 93, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 93, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st78[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 94, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 94, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st79[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 95, 96, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 95, 96, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st80[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 97, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 97, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st81[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 98, 43, 99, 43, 100, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 101, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 98, 43, 99, 43, 100, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 101, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st82[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 102, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 102, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st83[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 103, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 103, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st84[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 104, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 104, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st85[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 105, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 105, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st86[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 106, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 106, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st87[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 107, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 108, 43, 43, 436, 109, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 107, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 108, 43, 43, 436, 109, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st88[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 110, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 110, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st89[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 111, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 111, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st90[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 112, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 112, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st91[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 113, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 113, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st92[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 114, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st93[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 115, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 115, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st94[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 116, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 116, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st95[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 117, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 117, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st96[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 118, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 118, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st97[60] = {
> >
> > - 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > - 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
> >
> > - 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > - 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > - 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > + 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
> >
> > + 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > + 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > + 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st98[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 125, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 125, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st99[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 126, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 126, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st100[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 127, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 127, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st101[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 128, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 128, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st102[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 129, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 129, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st103[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st104[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 130, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 130, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st105[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 131, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 131, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st106[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 132, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 132, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st107[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 133, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 133, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st108[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 134, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 134, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st109[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 135, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 135, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st110[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 136, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 136, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st111[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 137, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 137, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st112[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 138, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 138, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st113[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 139, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 139, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st114[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 140, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 140, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st115[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st116[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st117[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st118[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st119[60] = {
> >
> > - 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st120[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st121[60] = {
> >
> > - 436, 436, 142, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 142, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st122[60] = {
> >
> > - 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st123[60] = {
> >
> > - 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > - 123, 123, 123, 123, 123, 123, 123, 122, 122, 122,
> >
> > - 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > - 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > - 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
> >
> > + 123, 123, 123, 123, 123, 123, 123, 122, 122, 122,
> >
> > + 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > + 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > + 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st124[60] = {
> >
> > - 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
> >
> > - 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
> >
> > - 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > - 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > - 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
> >
> > + 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
> >
> > + 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
> >
> > + 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
> >
> > + 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
> >
> > 122, 123, 122, 122, 123, 123, 123, 123, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st125[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 147, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 147, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st126[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 148, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 148, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st127[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 149, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 149, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st128[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 150, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 150, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st129[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 151, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 151, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st130[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 152, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 152, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st131[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 153, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 153, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st132[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 154,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 154,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st133[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st134[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 155, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 155, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st135[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 156, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 156, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st136[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 157, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 157, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st137[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st138[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 158, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 158, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st139[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st140[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 159, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 159, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st141[60] = {
> >
> > - 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st142[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st143[60] = {
> >
> > - 436, 143, 120, 121, 122, 122, 146, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 143, 120, 121, 122, 122, 146, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st144[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st145[60] = {
> >
> > - 436, 436, 160, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 160, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st146[60] = {
> >
> > - 436, 161, 162, 163, 161, 161, 122, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 436, 161, 162, 163, 161, 161, 122, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > 161, 161, 161, 161, 161, 161, 161, 161, 161, 436
> >
> > };
> >
> >
> >
> > static DfaState st147[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 164, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 164, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st148[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 165, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 165, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st149[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 166, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 166, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st150[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 167, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 167, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st151[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 168, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 168, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st152[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st153[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st154[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 169, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 169, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st155[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 170, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 170, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st156[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 171, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 171, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st157[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st158[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 172, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 172, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st159[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st160[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st161[60] = {
> >
> > - 436, 161, 162, 163, 161, 161, 173, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > - 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 436, 161, 162, 163, 161, 161, 173, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
> >
> > 161, 161, 161, 161, 161, 161, 161, 161, 161, 436
> >
> > };
> >
> >
> >
> > static DfaState st162[60] = {
> >
> > - 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
> >
> > };
> >
> >
> >
> > static DfaState st163[60] = {
> >
> > - 436, 174, 176, 174, 174, 174, 175, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 436, 174, 176, 174, 174, 174, 175, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
> >
> > };
> >
> >
> >
> > static DfaState st164[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 177, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 177, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st165[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 178, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 178, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st166[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 179, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 179, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st167[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 180, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 180, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st168[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 181, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 181, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st169[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 182, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 182, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st170[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st171[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 183, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 183, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st172[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 184, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 184, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st173[60] = {
> >
> > - 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st174[60] = {
> >
> > - 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
> >
> > };
> >
> >
> >
> > static DfaState st175[60] = {
> >
> > - 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st176[60] = {
> >
> > - 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > - 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
> >
> > 174, 174, 174, 174, 174, 174, 174, 174, 174, 436
> >
> > };
> >
> >
> >
> > static DfaState st177[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 191, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 191, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st178[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 192, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 192, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st179[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 193, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 193, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st180[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st181[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st182[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 194,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 194,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st183[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st184[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > - 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > - 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > - 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
> >
> > + 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
> >
> > + 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
> >
> > + 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
> >
> > 436, 50, 436, 436, 50, 50, 50, 50, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st185[60] = {
> >
> > - 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st186[60] = {
> >
> > - 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > - 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > + 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
> >
> > 122, 122, 122, 122, 122, 122, 122, 122, 122, 436
> >
> > };
> >
> >
> >
> > static DfaState st187[60] = {
> >
> > - 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st188[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st189[60] = {
> >
> > - 436, 436, 195, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 195, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st190[60] = {
> >
> > - 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st191[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st192[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st193[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st194[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 196, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 196, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st195[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st196[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 197, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 197, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st197[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 198, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 198, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st198[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 199, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 199, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st199[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 200, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 200, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st200[60] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > - 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > - 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > - 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
> >
> > + 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
> >
> > + 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
> >
> > + 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
> >
> > 436, 43, 436, 436, 43, 43, 43, 43, 436, 436
> >
> > };
> >
> >
> >
> > @@ -3978,1067 +3978,1067 @@ static DfaState st275[7] = {
> > };
> >
> >
> >
> > static DfaState st276[36] = {
> >
> > - 277, 278, 279, 280, 281, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 282, 279, 279, 283, 284,
> >
> > - 285, 286, 287, 279, 279, 279, 279, 288, 289, 290,
> >
> > + 277, 278, 279, 280, 281, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 282, 279, 279, 283, 284,
> >
> > + 285, 286, 287, 279, 279, 279, 279, 288, 289, 290,
> >
> > 291, 292, 293, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st277[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st278[36] = {
> >
> > - 436, 294, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 294, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st279[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st280[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st281[36] = {
> >
> > - 436, 436, 279, 436, 279, 295, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 295, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st282[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st283[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st284[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st285[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 296,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 296,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st286[36] = {
> >
> > - 436, 436, 436, 436, 297, 297, 297, 297, 297, 297,
> >
> > - 297, 297, 297, 297, 297, 436, 436, 436, 436, 436,
> >
> > - 436, 298, 299, 300, 300, 436, 297, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 297, 297, 297, 297, 297, 297,
> >
> > + 297, 297, 297, 297, 297, 436, 436, 436, 436, 436,
> >
> > + 436, 298, 299, 300, 300, 436, 297, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st287[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st288[36] = {
> >
> > - 436, 436, 436, 436, 301, 301, 301, 301, 301, 301,
> >
> > - 301, 301, 301, 301, 302, 303, 436, 436, 436, 436,
> >
> > - 436, 436, 304, 305, 306, 436, 301, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 301, 301, 301, 301, 301, 301,
> >
> > + 301, 301, 301, 301, 302, 303, 436, 436, 436, 436,
> >
> > + 436, 436, 304, 305, 306, 436, 301, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st289[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st290[36] = {
> >
> > - 436, 307, 308, 309, 308, 308, 308, 308, 308, 308,
> >
> > - 308, 308, 308, 308, 308, 308, 308, 308, 310, 311,
> >
> > - 312, 313, 308, 308, 308, 308, 308, 314, 308, 308,
> >
> > + 436, 307, 308, 309, 308, 308, 308, 308, 308, 308,
> >
> > + 308, 308, 308, 308, 308, 308, 308, 308, 310, 311,
> >
> > + 312, 313, 308, 308, 308, 308, 308, 314, 308, 308,
> >
> > 308, 308, 308, 308, 308, 436
> >
> > };
> >
> >
> >
> > static DfaState st291[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st292[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 315, 316, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st293[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 317, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st294[36] = {
> >
> > - 436, 436, 318, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 318, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st295[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 319, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 319, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st296[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st297[36] = {
> >
> > - 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
> >
> > - 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
> >
> > + 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st298[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st299[36] = {
> >
> > - 436, 436, 436, 321, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 321, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st300[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 300, 300, 322, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 300, 300, 322, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st301[36] = {
> >
> > - 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > - 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > + 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st302[36] = {
> >
> > - 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > - 323, 323, 323, 324, 323, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > + 323, 323, 323, 324, 323, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st303[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 325, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 325, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st304[36] = {
> >
> > - 436, 436, 436, 326, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 326, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st305[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st306[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st307[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st308[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st309[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st310[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st311[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st312[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 327,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 327,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st313[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st314[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st315[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st316[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st317[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st318[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st319[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 328, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 328, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st320[36] = {
> >
> > - 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
> >
> > - 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
> >
> > + 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st321[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st322[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st323[36] = {
> >
> > - 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > - 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > + 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st324[36] = {
> >
> > - 436, 436, 436, 436, 323, 323, 330, 323, 323, 323,
> >
> > - 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 323, 323, 330, 323, 323, 323,
> >
> > + 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st325[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st326[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st327[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st328[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 331, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 331, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st329[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st330[36] = {
> >
> > - 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > - 332, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
> >
> > + 332, 323, 323, 323, 323, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st331[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 333,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 333,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st332[36] = {
> >
> > - 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > - 335, 335, 335, 335, 335, 334, 336, 334, 334, 337,
> >
> > - 338, 334, 334, 339, 339, 334, 335, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > + 335, 335, 335, 335, 335, 334, 336, 334, 334, 337,
> >
> > + 338, 334, 334, 339, 339, 334, 335, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st333[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 340, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 340, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st334[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 334, 334, 334, 337,
> >
> > - 338, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 334, 334, 334, 337,
> >
> > + 338, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st335[36] = {
> >
> > - 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > - 335, 335, 335, 335, 335, 334, 334, 334, 334, 337,
> >
> > - 338, 334, 334, 335, 335, 334, 335, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > + 335, 335, 335, 335, 335, 334, 334, 334, 334, 337,
> >
> > + 338, 334, 334, 335, 335, 334, 335, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st336[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 336, 334, 334, 337,
> >
> > - 338, 334, 334, 341, 341, 334, 334, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 336, 334, 334, 337,
> >
> > + 338, 334, 334, 341, 341, 334, 334, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st337[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st338[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 342,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 342,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st339[36] = {
> >
> > - 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > - 335, 335, 335, 335, 335, 334, 343, 334, 334, 344,
> >
> > - 345, 334, 334, 339, 339, 334, 335, 334, 346, 334,
> >
> > + 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
> >
> > + 335, 335, 335, 335, 335, 334, 343, 334, 334, 344,
> >
> > + 345, 334, 334, 339, 339, 334, 335, 334, 346, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st340[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 347, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 347, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st341[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 343, 334, 334, 344,
> >
> > - 345, 334, 334, 341, 341, 334, 334, 334, 346, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 343, 334, 334, 344,
> >
> > + 345, 334, 334, 341, 341, 334, 334, 334, 346, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st342[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st343[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 343, 334, 334, 337,
> >
> > - 338, 334, 334, 334, 334, 334, 334, 334, 346, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 343, 334, 334, 337,
> >
> > + 338, 334, 334, 334, 334, 334, 334, 334, 346, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st344[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st345[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 348,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 348,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st346[36] = {
> >
> > - 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
> >
> > - 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
> >
> > - 351, 349, 349, 349, 349, 349, 349, 349, 334, 349,
> >
> > + 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
> >
> > + 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
> >
> > + 351, 349, 349, 349, 349, 349, 349, 349, 334, 349,
> >
> > 349, 349, 349, 349, 349, 436
> >
> > };
> >
> >
> >
> > static DfaState st347[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 352, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 352, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st348[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st349[36] = {
> >
> > - 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
> >
> > - 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
> >
> > - 351, 349, 349, 349, 349, 349, 349, 349, 353, 349,
> >
> > + 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
> >
> > + 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
> >
> > + 351, 349, 349, 349, 349, 349, 349, 349, 353, 349,
> >
> > 349, 349, 349, 349, 349, 436
> >
> > };
> >
> >
> >
> > static DfaState st350[36] = {
> >
> > - 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > + 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > 354, 354, 354, 354, 354, 436
> >
> > };
> >
> >
> >
> > static DfaState st351[36] = {
> >
> > - 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 354, 356,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > + 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 354, 356,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > 354, 354, 354, 354, 354, 436
> >
> > };
> >
> >
> >
> > static DfaState st352[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 357, 279, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 357, 279, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st353[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > - 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > + 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st354[36] = {
> >
> > - 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > + 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > 354, 354, 354, 354, 354, 436
> >
> > };
> >
> >
> >
> > static DfaState st355[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > - 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > + 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st356[36] = {
> >
> > - 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > - 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > + 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
> >
> > + 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
> >
> > 354, 354, 354, 354, 354, 436
> >
> > };
> >
> >
> >
> > static DfaState st357[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 364, 279, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 364, 279, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st358[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > - 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > + 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st359[36] = {
> >
> > - 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > - 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > - 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > + 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
> >
> > + 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
> >
> > + 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
> >
> > 334, 334, 334, 334, 334, 436
> >
> > };
> >
> >
> >
> > static DfaState st360[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > - 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > + 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st361[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st362[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 365,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 365,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st363[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > - 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
> >
> > + 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st364[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 366, 436, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 366, 436, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st365[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st366[36] = {
> >
> > - 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > - 279, 279, 279, 279, 279, 367, 279, 279, 436, 436,
> >
> > - 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > + 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
> >
> > + 279, 279, 279, 279, 279, 367, 279, 279, 436, 436,
> >
> > + 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
> >
> > 436, 436, 279, 279, 279, 436
> >
> > };
> >
> >
> >
> > static DfaState st367[36] = {
> >
> > - 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 369, 370, 436, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 369, 370, 436, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > 368, 368, 368, 368, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st368[36] = {
> >
> > - 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 371, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 371, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > 368, 368, 368, 368, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st369[36] = {
> >
> > - 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 369, 370, 371, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 369, 370, 371, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > 368, 368, 368, 368, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st370[36] = {
> >
> > - 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > - 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
> >
> > - 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > + 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > + 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
> >
> > + 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > 372, 372, 372, 372, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st371[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st372[36] = {
> >
> > - 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > - 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
> >
> > - 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > + 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > + 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
> >
> > + 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
> >
> > 372, 372, 372, 372, 374, 436
> >
> > };
> >
> >
> >
> > static DfaState st373[36] = {
> >
> > - 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > 375, 375, 375, 375, 376, 436
> >
> > };
> >
> >
> >
> > static DfaState st374[36] = {
> >
> > - 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > 368, 368, 368, 368, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st375[36] = {
> >
> > - 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
> >
> > 375, 375, 375, 375, 376, 436
> >
> > };
> >
> >
> >
> > static DfaState st376[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st377[36] = {
> >
> > - 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
> >
> > - 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
> >
> > + 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
> >
> > 368, 368, 368, 368, 368, 436
> >
> > };
> >
> >
> >
> > static DfaState st378[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st379[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st380[36] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st381[28] = {
> >
> > - 382, 383, 384, 385, 386, 436, 387, 388, 388, 388,
> >
> > - 389, 388, 388, 388, 388, 388, 388, 388, 388, 388,
> >
> > + 382, 383, 384, 385, 386, 436, 387, 388, 388, 388,
> >
> > + 389, 388, 388, 388, 388, 388, 388, 388, 388, 388,
> >
> > 390, 391, 392, 393, 394, 395, 388, 436
> >
> > };
> >
> >
> >
> > static DfaState st382[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st383[28] = {
> >
> > - 436, 383, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 383, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st384[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st385[28] = {
> >
> > - 436, 436, 396, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 396, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st386[28] = {
> >
> > - 436, 436, 436, 436, 397, 398, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 397, 398, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st387[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 399, 436, 400,
> >
> > - 401, 436, 436, 436, 402, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 399, 436, 400,
> >
> > + 401, 436, 436, 436, 402, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st388[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st389[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 404, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 404, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st390[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st391[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st392[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st393[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st394[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st395[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 395, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st396[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st397[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st398[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st399[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 405, 436,
> >
> > - 436, 436, 436, 436, 436, 406, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 405, 436,
> >
> > + 436, 436, 436, 436, 436, 406, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st400[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 407, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 407, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st401[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 408, 409, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 408, 409, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st402[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 410, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 410, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st403[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st404[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 403, 403, 403, 411, 403, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 403, 403, 403, 411, 403, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st405[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 412,
> >
> > - 436, 413, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 412,
> >
> > + 436, 413, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st406[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 414, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 414, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st407[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 415, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 415, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st408[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 416,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 416,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st409[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 417, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 417, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st410[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 418,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 418,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st411[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 403, 403, 403, 403, 419, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 403, 403, 403, 403, 419, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st412[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 420, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 420, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st413[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 421,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 421,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st414[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 422, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 422, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st415[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 423, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 423, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st416[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 424, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 424, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st417[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 425, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 425, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st418[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 426, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 426, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st419[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > - 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
> >
> > + 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
> >
> > 436, 436, 436, 436, 436, 403, 403, 436
> >
> > };
> >
> >
> >
> > static DfaState st420[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 427, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 427, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st421[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 428, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 428, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st422[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 429, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 429, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st423[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 430, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 430, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st424[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 431, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 431, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st425[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st426[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 432, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 432, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st427[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st428[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 433, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 433, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st429[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 434,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 434,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st430[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 435, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 435, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st431[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st432[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st433[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st434[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > static DfaState st435[28] = {
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > + 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
> >
> > 436, 436, 436, 436, 436, 436, 436, 436
> >
> > };
> >
> >
> >
> > @@ -5484,49 +5484,49 @@ DfaState *dfa[436] = {
> >
> >
> >
> >
> > DfaState accepts[437] = {
> >
> > - 0, 1, 2, 3, 3, 4, 25, 6, 0, 50,
> >
> > - 59, 57, 57, 43, 26, 13, 14, 0, 57, 58,
> >
> > - 57, 21, 57, 23, 24, 27, 28, 44, 0, 35,
> >
> > - 36, 42, 45, 46, 58, 51, 52, 3, 5, 9,
> >
> > - 7, 8, 59, 59, 59, 59, 59, 59, 59, 59,
> >
> > - 57, 57, 12, 40, 59, 57, 58, 57, 57, 57,
> >
> > - 33, 34, 53, 58, 59, 59, 59, 59, 59, 59,
> >
> > - 59, 59, 59, 57, 59, 57, 57, 57, 57, 0,
> >
> > - 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
> >
> > - 57, 57, 57, 57, 57, 0, 0, 59, 59, 59,
> >
> > - 59, 59, 59, 32, 59, 59, 59, 59, 59, 59,
> >
> > - 59, 59, 57, 57, 57, 22, 56, 48, 49, 0,
> >
> > - 11, 11, 0, 59, 59, 59, 59, 59, 59, 59,
> >
> > - 59, 59, 59, 41, 59, 59, 59, 18, 57, 47,
> >
> > - 57, 0, 11, 0, 10, 10, 0, 59, 59, 59,
> >
> > - 59, 59, 15, 19, 59, 59, 59, 17, 57, 55,
> >
> > - 10, 0, 11, 11, 59, 59, 59, 59, 59, 59,
> >
> > - 20, 59, 57, 0, 0, 0, 11, 59, 59, 59,
> >
> > - 37, 38, 59, 39, 54, 0, 0, 0, 10, 10,
> >
> > - 0, 31, 29, 30, 59, 10, 59, 59, 59, 59,
> >
> > - 16, 0, 60, 61, 62, 62, 0, 65, 62, 64,
> >
> > - 63, 63, 63, 0, 66, 67, 68, 68, 0, 71,
> >
> > - 68, 70, 69, 69, 69, 0, 72, 73, 74, 74,
> >
> > - 0, 76, 74, 75, 0, 77, 79, 81, 80, 80,
> >
> > - 78, 80, 0, 82, 84, 86, 85, 85, 83, 85,
> >
> > - 0, 87, 88, 88, 89, 88, 0, 90, 91, 91,
> >
> > - 92, 91, 0, 93, 94, 94, 95, 94, 0, 96,
> >
> > - 98, 100, 99, 99, 97, 99, 0, 101, 108, 143,
> >
> > - 104, 143, 129, 127, 107, 107, 109, 128, 126, 134,
> >
> > - 0, 133, 139, 143, 102, 143, 107, 116, 110, 112,
> >
> > - 113, 123, 123, 125, 124, 117, 120, 132, 138, 130,
> >
> > - 131, 137, 137, 135, 136, 142, 140, 141, 103, 143,
> >
> > - 116, 111, 114, 123, 123, 119, 118, 137, 143, 115,
> >
> > - 123, 143, 123, 143, 0, 123, 0, 122, 122, 123,
> >
> > - 143, 0, 122, 0, 121, 121, 0, 143, 121, 0,
> >
> > - 122, 122, 143, 0, 0, 0, 122, 143, 0, 0,
> >
> > - 0, 121, 121, 0, 143, 121, 143, 0, 0, 0,
> >
> > - 0, 106, 0, 106, 0, 0, 0, 0, 105, 0,
> >
> > - 105, 0, 144, 145, 146, 146, 0, 0, 164, 164,
> >
> > - 158, 159, 160, 161, 162, 163, 146, 147, 148, 0,
> >
> > - 0, 0, 0, 164, 164, 150, 0, 0, 0, 0,
> >
> > - 0, 164, 0, 0, 0, 0, 0, 0, 0, 157,
> >
> > - 0, 0, 0, 0, 0, 152, 0, 149, 0, 0,
> >
> > + 0, 1, 2, 3, 3, 4, 25, 6, 0, 50,
> >
> > + 59, 57, 57, 43, 26, 13, 14, 0, 57, 58,
> >
> > + 57, 21, 57, 23, 24, 27, 28, 44, 0, 35,
> >
> > + 36, 42, 45, 46, 58, 51, 52, 3, 5, 9,
> >
> > + 7, 8, 59, 59, 59, 59, 59, 59, 59, 59,
> >
> > + 57, 57, 12, 40, 59, 57, 58, 57, 57, 57,
> >
> > + 33, 34, 53, 58, 59, 59, 59, 59, 59, 59,
> >
> > + 59, 59, 59, 57, 59, 57, 57, 57, 57, 0,
> >
> > + 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
> >
> > + 57, 57, 57, 57, 57, 0, 0, 59, 59, 59,
> >
> > + 59, 59, 59, 32, 59, 59, 59, 59, 59, 59,
> >
> > + 59, 59, 57, 57, 57, 22, 56, 48, 49, 0,
> >
> > + 11, 11, 0, 59, 59, 59, 59, 59, 59, 59,
> >
> > + 59, 59, 59, 41, 59, 59, 59, 18, 57, 47,
> >
> > + 57, 0, 11, 0, 10, 10, 0, 59, 59, 59,
> >
> > + 59, 59, 15, 19, 59, 59, 59, 17, 57, 55,
> >
> > + 10, 0, 11, 11, 59, 59, 59, 59, 59, 59,
> >
> > + 20, 59, 57, 0, 0, 0, 11, 59, 59, 59,
> >
> > + 37, 38, 59, 39, 54, 0, 0, 0, 10, 10,
> >
> > + 0, 31, 29, 30, 59, 10, 59, 59, 59, 59,
> >
> > + 16, 0, 60, 61, 62, 62, 0, 65, 62, 64,
> >
> > + 63, 63, 63, 0, 66, 67, 68, 68, 0, 71,
> >
> > + 68, 70, 69, 69, 69, 0, 72, 73, 74, 74,
> >
> > + 0, 76, 74, 75, 0, 77, 79, 81, 80, 80,
> >
> > + 78, 80, 0, 82, 84, 86, 85, 85, 83, 85,
> >
> > + 0, 87, 88, 88, 89, 88, 0, 90, 91, 91,
> >
> > + 92, 91, 0, 93, 94, 94, 95, 94, 0, 96,
> >
> > + 98, 100, 99, 99, 97, 99, 0, 101, 108, 143,
> >
> > + 104, 143, 129, 127, 107, 107, 109, 128, 126, 134,
> >
> > + 0, 133, 139, 143, 102, 143, 107, 116, 110, 112,
> >
> > + 113, 123, 123, 125, 124, 117, 120, 132, 138, 130,
> >
> > + 131, 137, 137, 135, 136, 142, 140, 141, 103, 143,
> >
> > + 116, 111, 114, 123, 123, 119, 118, 137, 143, 115,
> >
> > + 123, 143, 123, 143, 0, 123, 0, 122, 122, 123,
> >
> > + 143, 0, 122, 0, 121, 121, 0, 143, 121, 0,
> >
> > + 122, 122, 143, 0, 0, 0, 122, 143, 0, 0,
> >
> > + 0, 121, 121, 0, 143, 121, 143, 0, 0, 0,
> >
> > + 0, 106, 0, 106, 0, 0, 0, 0, 105, 0,
> >
> > + 105, 0, 144, 145, 146, 146, 0, 0, 164, 164,
> >
> > + 158, 159, 160, 161, 162, 163, 146, 147, 148, 0,
> >
> > + 0, 0, 0, 164, 164, 150, 0, 0, 0, 0,
> >
> > + 0, 164, 0, 0, 0, 0, 0, 0, 0, 157,
> >
> > + 0, 0, 0, 0, 0, 152, 0, 149, 0, 0,
> >
> > 0, 153, 154, 151, 155, 156, 0
> >
> > };
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
> > index 2d473ec8b663..e4ec2b77938b 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
> > @@ -51,7 +51,7 @@ dfa_node *dfa_model_node;
> > hash_list *dfa_hash[HASH_SIZE]; /* used to quickly find */
> >
> > /* desired dfa node */
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > make_dfa_model_node(int width)
> >
> > #else
> >
> > @@ -143,7 +143,7 @@ nfa_node *start;
> > /* Make t a dfa state */
> >
> > d_state = dfastate(t);
> >
> > last_done = DFA_NO(d_state);
> >
> > -
> >
> > +
> >
> > do {
> >
> > /* Mark dfa state x as "done" */
> >
> > d_state->done = TRUE;
> >
> > @@ -177,7 +177,7 @@ nfa_node *start;
> > return dfa_array;
> >
> > }
> >
> >
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > clear_hash(void)
> >
> > #else
> >
> > @@ -250,7 +250,7 @@ set nfa_states;
> >
> >
> >
> >
> > /* this reach assumes the closure has been done already on set */
> >
> > -int
> >
> > +int
> >
> > #ifdef __USE_PROTOS
> >
> > reach(unsigned *nfa_list, register int a, unsigned *reach_list)
> >
> > #else
> >
> > @@ -282,7 +282,7 @@ unsigned *reach_list;
> >
> >
> > /* finds all the nodes that can be reached by epsilon transitions
> >
> > from the set of a nodes and returns puts them back in set b */
> >
> > -set
> >
> > +set
> >
> > #ifdef __USE_PROTOS
> >
> > closure(set *b, unsigned *reach_list)
> >
> > #else
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
> > index 97d1718c70ef..022e2de1bae7 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
> > @@ -28,7 +28,7 @@
> >
> >
> > /* MR1 Move pcctscfg.h to top of file */
> >
> >
> >
> > -#include "pcctscfg.h"
> >
> > +#include "pcctscfg.h"
> >
> >
> >
> > /* turn off warnings for unreferenced labels */
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
> > index 0b8982cf2a09..e4380c6c4e6c 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
> > @@ -76,7 +76,7 @@ void xxputc(int c) { /* MR1 */
> > fputc(c,OUT); /* MR1 */
> >
> > }; /* MR1 */
> >
> > } /* MR1 */
> >
> > -
> >
> > +
> >
> > #ifdef __USE_PROTOS
> >
> > void xxprintf(char *format,char *string) { /* MR1 */
> >
> > #else
> >
> > @@ -94,46 +94,46 @@ void xxputc(int c) { /* MR1 */
> > } /* MR1 */
> >
> >
> >
> > static void act1()
> >
> > -{
> >
> > +{
> >
> > NLA = 1;
> >
> > }
> >
> >
> >
> >
> >
> > static void act2()
> >
> > -{
> >
> > +{
> >
> > NLA = 2;
> >
> > - zzskip();
> >
> > + zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act3()
> >
> > -{
> >
> > +{
> >
> > NLA = 3;
> >
> > - zzline++; zzskip(); DAWDLE;
> >
> > + zzline++; zzskip(); DAWDLE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act4()
> >
> > -{
> >
> > +{
> >
> > NLA = L_EOF;
> >
> > }
> >
> >
> >
> >
> >
> > static void act5()
> >
> > -{
> >
> > +{
> >
> > NLA = PER_PER;
> >
> > }
> >
> >
> >
> >
> >
> > static void act6()
> >
> > -{
> >
> > +{
> >
> > NLA = NAME_PER_PER;
> >
> > - p_mode_def(&zzlextext[2],lex_mode_counter++);
> >
> > + p_mode_def(&zzlextext[2],lex_mode_counter++);
> >
> > }
> >
> >
> >
> >
> >
> > static void act7()
> >
> > -{
> >
> > +{
> >
> > NLA = LEXMEMBER;
> >
> > lexMember=1; /* MR1 */
> >
> > if (firstLexMember != 0) { /* MR1 */
> >
> > @@ -145,14 +145,14 @@ static void act7()
> >
> >
> >
> >
> > static void act8()
> >
> > -{
> >
> > +{
> >
> > NLA = LEXACTION;
> >
> > - lexAction=1;zzmode(ACT);
> >
> > + lexAction=1;zzmode(ACT);
> >
> > }
> >
> >
> >
> >
> >
> > static void act9()
> >
> > -{
> >
> > +{
> >
> > NLA = PARSERCLASS;
> >
> > parserClass=1; /* MR1 */
> >
> > zzmode(ACT); /* MR1 */
> >
> > @@ -160,14 +160,14 @@ static void act9()
> >
> >
> >
> >
> > static void act10()
> >
> > -{
> >
> > +{
> >
> > NLA = LEXPREFIX;
> >
> > - lexPrefix=1;zzmode(ACT);
> >
> > + lexPrefix=1;zzmode(ACT);
> >
> > }
> >
> >
> >
> >
> >
> > static void act11()
> >
> > -{
> >
> > +{
> >
> > NLA = ACTION;
> >
> > if (func_action)
> >
> > fprintf(OUT,"\n%s %sact%d()\n{ ",
> >
> > @@ -178,184 +178,184 @@ static void act11()
> >
> >
> >
> >
> > static void act12()
> >
> > -{
> >
> > +{
> >
> > NLA = GREAT_GREAT;
> >
> > }
> >
> >
> >
> >
> >
> > static void act13()
> >
> > -{
> >
> > +{
> >
> > NLA = L_BRACE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act14()
> >
> > -{
> >
> > +{
> >
> > NLA = R_BRACE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act15()
> >
> > -{
> >
> > +{
> >
> > NLA = L_PAR;
> >
> > }
> >
> >
> >
> >
> >
> > static void act16()
> >
> > -{
> >
> > +{
> >
> > NLA = R_PAR;
> >
> > }
> >
> >
> >
> >
> >
> > static void act17()
> >
> > -{
> >
> > +{
> >
> > NLA = L_BRACK;
> >
> > }
> >
> >
> >
> >
> >
> > static void act18()
> >
> > -{
> >
> > +{
> >
> > NLA = R_BRACK;
> >
> > }
> >
> >
> >
> >
> >
> > static void act19()
> >
> > -{
> >
> > +{
> >
> > NLA = ZERO_MORE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act20()
> >
> > -{
> >
> > +{
> >
> > NLA = ONE_MORE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act21()
> >
> > -{
> >
> > +{
> >
> > NLA = OR;
> >
> > }
> >
> >
> >
> >
> >
> > static void act22()
> >
> > -{
> >
> > +{
> >
> > NLA = RANGE;
> >
> > }
> >
> >
> >
> >
> >
> > static void act23()
> >
> > -{
> >
> > +{
> >
> > NLA = NOT;
> >
> > }
> >
> >
> >
> >
> >
> > static void act24()
> >
> > -{
> >
> > +{
> >
> > NLA = OCTAL_VALUE;
> >
> > - {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
> >
> > + {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
> >
> > }
> >
> >
> >
> >
> >
> > static void act25()
> >
> > -{
> >
> > +{
> >
> > NLA = HEX_VALUE;
> >
> > - {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
> >
> > + {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
> >
> > }
> >
> >
> >
> >
> >
> > static void act26()
> >
> > -{
> >
> > +{
> >
> > NLA = DEC_VALUE;
> >
> > - {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
> >
> > + {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
> >
> > }
> >
> >
> >
> >
> >
> > static void act27()
> >
> > -{
> >
> > +{
> >
> > NLA = TAB;
> >
> > - zzlextext[0] = '\t';
> >
> > + zzlextext[0] = '\t';
> >
> > }
> >
> >
> >
> >
> >
> > static void act28()
> >
> > -{
> >
> > +{
> >
> > NLA = NL;
> >
> > - zzlextext[0] = '\n';
> >
> > + zzlextext[0] = '\n';
> >
> > }
> >
> >
> >
> >
> >
> > static void act29()
> >
> > -{
> >
> > +{
> >
> > NLA = CR;
> >
> > - zzlextext[0] = '\r';
> >
> > + zzlextext[0] = '\r';
> >
> > }
> >
> >
> >
> >
> >
> > static void act30()
> >
> > -{
> >
> > +{
> >
> > NLA = BS;
> >
> > - zzlextext[0] = '\b';
> >
> > + zzlextext[0] = '\b';
> >
> > }
> >
> >
> >
> >
> >
> > static void act31()
> >
> > -{
> >
> > +{
> >
> > NLA = CONTINUATION;
> >
> > - zzline++; zzskip();
> >
> > + zzline++; zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act32()
> >
> > -{
> >
> > +{
> >
> > NLA = LIT;
> >
> > - zzlextext[0] = zzlextext[1];
> >
> > + zzlextext[0] = zzlextext[1];
> >
> > }
> >
> >
> >
> >
> >
> > static void act33()
> >
> > -{
> >
> > +{
> >
> > NLA = REGCHAR;
> >
> > }
> >
> >
> >
> > static unsigned char shift0[257] = {
> >
> > - 0, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 1, 2, 40, 40, 1, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 1, 40, 40, 40, 40, 4, 40,
> >
> > - 40, 30, 31, 34, 35, 40, 37, 40, 40, 23,
> >
> > - 24, 24, 24, 24, 24, 24, 24, 25, 25, 40,
> >
> > - 40, 26, 40, 27, 40, 3, 21, 21, 21, 21,
> >
> > - 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
> >
> > - 22, 22, 22, 22, 22, 22, 22, 22, 22, 20,
> >
> > - 22, 22, 32, 39, 33, 40, 22, 40, 11, 9,
> >
> > - 12, 21, 6, 19, 22, 22, 14, 22, 22, 5,
> >
> > - 8, 16, 15, 17, 22, 10, 18, 13, 22, 22,
> >
> > - 22, 7, 22, 22, 28, 36, 29, 38, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > - 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 0, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 1, 2, 40, 40, 1, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 1, 40, 40, 40, 40, 4, 40,
> >
> > + 40, 30, 31, 34, 35, 40, 37, 40, 40, 23,
> >
> > + 24, 24, 24, 24, 24, 24, 24, 25, 25, 40,
> >
> > + 40, 26, 40, 27, 40, 3, 21, 21, 21, 21,
> >
> > + 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
> >
> > + 22, 22, 22, 22, 22, 22, 22, 22, 22, 20,
> >
> > + 22, 22, 32, 39, 33, 40, 22, 40, 11, 9,
> >
> > + 12, 21, 6, 19, 22, 22, 14, 22, 22, 5,
> >
> > + 8, 16, 15, 17, 22, 10, 18, 13, 22, 22,
> >
> > + 22, 7, 22, 22, 28, 36, 29, 38, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > + 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
> >
> > 40, 40, 40, 40, 40, 40, 40
> >
> > };
> >
> >
> >
> >
> >
> > static void act34()
> >
> > -{
> >
> > +{
> >
> > NLA = 1;
> >
> > - error("unterminated action", zzline); zzmode(START);
> >
> > + error("unterminated action", zzline); zzmode(START);
> >
> > }
> >
> >
> >
> >
> >
> > static void act35()
> >
> > -{
> >
> > +{
> >
> > NLA = ACTION;
> >
> > if (func_action) fprintf(OUT,"}\n\n");
> >
> > zzmode(START);
> >
> > @@ -364,7 +364,7 @@ static void act35()
> > /* MR1 via <<%%lexmember ...>> */
> >
> > /* MR1 This is a consequence of not saving actions */
> >
> > /* MR1 */
> >
> > - /* MR1 */ parserClass=0;
> >
> > + /* MR1 */ parserClass=0;
> >
> > /* MR1 */ lexPrefix=0;
> >
> > /* MR1 */ lexAction=0;
> >
> > /* MR1 */ lexMember=0;
> >
> > @@ -372,35 +372,35 @@ static void act35()
> >
> >
> >
> >
> > static void act36()
> >
> > -{
> >
> > +{
> >
> > NLA = 34;
> >
> > - xxputc(zzlextext[0]); zzskip();
> >
> > + xxputc(zzlextext[0]); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act37()
> >
> > -{
> >
> > +{
> >
> > NLA = 35;
> >
> > - xxputc('>'); zzskip();
> >
> > + xxputc('>'); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act38()
> >
> > -{
> >
> > +{
> >
> > NLA = 36;
> >
> > - xxputc('\\'); zzskip();
> >
> > + xxputc('\\'); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act39()
> >
> > -{
> >
> > +{
> >
> > NLA = 37;
> >
> > - xxputc(zzlextext[0]); ++zzline; zzskip();
> >
> > + xxputc(zzlextext[0]); ++zzline; zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act40()
> >
> > -{
> >
> > +{
> >
> > NLA = 38;
> >
> > zzmode(ACTION_COMMENTS); /* MR1 */
> >
> > xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
> >
> > @@ -408,7 +408,7 @@ static void act40()
> >
> >
> >
> >
> > static void act41()
> >
> > -{
> >
> > +{
> >
> > NLA = 39;
> >
> > zzmode(ACTION_CPP_COMMENTS); /* MR1 */
> >
> > xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
> >
> > @@ -416,49 +416,49 @@ static void act41()
> >
> >
> >
> >
> > static void act42()
> >
> > -{
> >
> > +{
> >
> > NLA = 40;
> >
> > - xxputc(zzlextext[0]); zzskip();
> >
> > + xxputc(zzlextext[0]); zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift1[257] = {
> >
> > - 0, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 3, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 5, 6, 6, 6, 6, 4, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 1, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 2, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 0, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 3, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 5, 6, 6, 6, 6, 4, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 1, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 2, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > 6, 6, 6, 6, 6, 6, 6
> >
> > };
> >
> >
> >
> >
> >
> > static void act43()
> >
> > -{
> >
> > +{
> >
> > NLA = 1;
> >
> > }
> >
> >
> >
> >
> >
> > static void act44()
> >
> > -{
> >
> > +{
> >
> > NLA = 41;
> >
> > zzmode(ACT); /* MR1 */
> >
> > xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
> >
> > @@ -466,56 +466,56 @@ static void act44()
> >
> >
> >
> >
> > static void act45()
> >
> > -{
> >
> > +{
> >
> > NLA = 42;
> >
> > - zzline++; xxputc(zzlextext[0]); zzskip();
> >
> > + zzline++; xxputc(zzlextext[0]); zzskip();
> >
> > }
> >
> >
> >
> >
> >
> > static void act46()
> >
> > -{
> >
> > +{
> >
> > NLA = 43;
> >
> > - xxputc(zzlextext[0]); zzskip();
> >
> > + xxputc(zzlextext[0]); zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift2[257] = {
> >
> > - 0, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 3, 4, 4, 3, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 1, 4, 4, 4, 4, 2, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 0, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 3, 4, 4, 3, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 1, 4, 4, 4, 4, 2, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
> >
> > 4, 4, 4, 4, 4, 4, 4
> >
> > };
> >
> >
> >
> >
> >
> > static void act47()
> >
> > -{
> >
> > +{
> >
> > NLA = 1;
> >
> > }
> >
> >
> >
> >
> >
> > static void act48()
> >
> > -{
> >
> > +{
> >
> > NLA = 44;
> >
> > zzmode(ACT); zzline++; /* MR1 */
> >
> > xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
> >
> > @@ -523,37 +523,37 @@ static void act48()
> >
> >
> >
> >
> > static void act49()
> >
> > -{
> >
> > +{
> >
> > NLA = 45;
> >
> > - xxputc(zzlextext[0]); zzskip();
> >
> > + xxputc(zzlextext[0]); zzskip();
> >
> > }
> >
> >
> >
> > static unsigned char shift3[257] = {
> >
> > - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 1, 2, 2, 1, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 1, 2, 2, 1, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
> >
> > 2, 2, 2, 2, 2, 2, 2
> >
> > };
> >
> >
> >
> > @@ -561,586 +561,586 @@ static unsigned char shift3[257] = {
> > typedef unsigned char DfaState;
> >
> >
> >
> > static DfaState st0[42] = {
> >
> > - 1, 2, 3, 4, 5, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > - 6, 6, 6, 6, 6, 6, 7, 8, 9, 10,
> >
> > - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
> >
> > + 1, 2, 3, 4, 5, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
> >
> > + 6, 6, 6, 6, 6, 6, 7, 8, 9, 10,
> >
> > + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
> >
> > 6, 94
> >
> > };
> >
> >
> >
> > static DfaState st1[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st2[42] = {
> >
> > - 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st3[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st4[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st5[42] = {
> >
> > - 94, 94, 94, 94, 22, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 22, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st6[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st7[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 23, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 23, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st8[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 24, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 24, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st9[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st10[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st11[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st12[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st13[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st14[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st15[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st16[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st17[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st18[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st19[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st20[42] = {
> >
> > - 94, 25, 26, 25, 25, 25, 25, 25, 25, 27,
> >
> > - 28, 25, 25, 29, 25, 25, 30, 25, 25, 25,
> >
> > - 25, 25, 25, 31, 32, 32, 25, 25, 25, 25,
> >
> > - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
> >
> > + 94, 25, 26, 25, 25, 25, 25, 25, 25, 27,
> >
> > + 28, 25, 25, 29, 25, 25, 30, 25, 25, 25,
> >
> > + 25, 25, 25, 31, 32, 32, 25, 25, 25, 25,
> >
> > + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
> >
> > 25, 94
> >
> > };
> >
> >
> >
> > static DfaState st21[42] = {
> >
> > - 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st22[42] = {
> >
> > - 94, 94, 94, 94, 94, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > - 33, 33, 33, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
> >
> > + 33, 33, 33, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st23[42] = {
> >
> > - 94, 94, 94, 94, 34, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 34, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st24[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st25[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st26[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st27[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st28[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st29[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st30[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st31[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 35, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 35, 94, 94, 36, 36, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 35, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 35, 94, 94, 36, 36, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st32[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st33[42] = {
> >
> > - 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
> >
> > - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
> >
> > - 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
> >
> > + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
> >
> > + 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st34[42] = {
> >
> > - 94, 94, 94, 94, 39, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 39, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st35[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
> >
> > - 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
> >
> > - 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
> >
> > + 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
> >
> > + 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st36[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 36, 36, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 36, 36, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st37[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st38[42] = {
> >
> > - 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
> >
> > - 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
> >
> > - 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
> >
> > + 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
> >
> > + 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st39[42] = {
> >
> > - 94, 94, 94, 94, 94, 41, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 42, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 41, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 42, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st40[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
> >
> > - 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
> >
> > - 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
> >
> > + 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
> >
> > + 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st41[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 43, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 43, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st42[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 44, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 44, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st43[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 45, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 45, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st44[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 46, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 46, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st45[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 47, 94,
> >
> > - 94, 48, 94, 94, 94, 94, 94, 49, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 47, 94,
> >
> > + 94, 48, 94, 94, 94, 94, 94, 49, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st46[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 50, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 50, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st47[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 51, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 51, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st48[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 52, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 52, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st49[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 53, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 53, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st50[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 54, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 54, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st51[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 55, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 55, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st52[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 56, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 56, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st53[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 57, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 57, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st54[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 58, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 58, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st55[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 59,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 59,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st56[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 60, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 60, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st57[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 61,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 61,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st58[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 62, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 62, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st59[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 63, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 63, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st60[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 64, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 64, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st61[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 65, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 65, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st62[42] = {
> >
> > - 94, 94, 94, 94, 94, 66, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 66, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st63[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 67, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 67, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st64[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 68, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 68, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st65[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 69, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 69, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st66[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 70, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 70, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st67[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st68[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st69[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st70[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 71, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 71, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st71[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 72, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 72, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > static DfaState st72[42] = {
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > - 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > + 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
> >
> > 94, 94
> >
> > };
> >
> >
> >
> > @@ -1328,15 +1328,15 @@ DfaState *dfa[94] = {
> >
> >
> >
> >
> > DfaState accepts[95] = {
> >
> > - 0, 1, 2, 3, 4, 33, 33, 33, 33, 13,
> >
> > - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
> >
> > - 0, 2, 5, 11, 12, 32, 31, 30, 29, 27,
> >
> > - 28, 24, 26, 6, 0, 0, 24, 26, 6, 0,
> >
> > - 25, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> >
> > - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> >
> > - 0, 0, 0, 0, 0, 0, 0, 7, 8, 10,
> >
> > - 0, 0, 9, 0, 34, 36, 38, 39, 42, 42,
> >
> > - 35, 37, 41, 40, 0, 43, 46, 46, 45, 44,
> >
> > + 0, 1, 2, 3, 4, 33, 33, 33, 33, 13,
> >
> > + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
> >
> > + 0, 2, 5, 11, 12, 32, 31, 30, 29, 27,
> >
> > + 28, 24, 26, 6, 0, 0, 24, 26, 6, 0,
> >
> > + 25, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> >
> > + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> >
> > + 0, 0, 0, 0, 0, 0, 0, 7, 8, 10,
> >
> > + 0, 0, 9, 0, 34, 36, 38, 39, 42, 42,
> >
> > + 35, 37, 41, 40, 0, 43, 46, 46, 45, 44,
> >
> > 0, 47, 48, 49, 0
> >
> > };
> >
> >
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
> > index fbaf93afc63c..70101282e432 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
> > @@ -31,7 +31,7 @@
> > ANTLR_INFO
> >
> >
> >
> >
> >
> > -/* MR20 G. Hobbelt
> >
> > +/* MR20 G. Hobbelt
> >
> > Fix for Borland C++ 4.x & 5.x compiling with ALL warnings enabled
> >
> > */
> >
> >
> >
> > @@ -53,7 +53,7 @@ int flag_paren = FALSE;
> > int flag_brace = FALSE;
> >
> > int mode_counter = 0; /* keep track of number of %%names */
> >
> >
> >
> > -
> >
> > +
> >
> >
> >
> > void
> >
> > #ifdef __USE_PROTOS
> >
> > @@ -199,7 +199,7 @@ do_conversion()
> > {
> >
> > new_automaton_mode(); func_action = TRUE;
> >
> > rule_list();
> >
> > -
> >
> > +
> >
> > dfa_class_nop[mode_counter] =
> >
> > relabel(zzaArg(zztasp1,1 ).l,comp_level);
> >
> > if (comp_level)
> >
> > @@ -365,7 +365,7 @@ and_expr()
> > zzMake0;
> >
> > {
> >
> > repeat_expr();
> >
> > -
> >
> > +
> >
> > zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
> >
> > {
> >
> > zzBLOCK(zztasp2);
> >
> > @@ -482,7 +482,7 @@ expr()
> > zzmatch(L_BRACK); zzCONSUME;
> >
> > atom_list();
> >
> > zzmatch(R_BRACK);
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (zzaRet.l != NULL) {
> >
> > (zzaRet.l)->trans[0] = zzaRet.r;
> >
> > (zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
> >
> > @@ -497,7 +497,7 @@ expr()
> > zzmatch(L_BRACK); zzCONSUME;
> >
> > atom_list();
> >
> > zzmatch(R_BRACK);
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (zzaRet.l != NULL) {
> >
> > (zzaRet.l)->trans[0] = zzaRet.r;
> >
> > (zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
> >
> > @@ -511,8 +511,8 @@ expr()
> > zzmatch(L_PAR); zzCONSUME;
> >
> > reg_expr();
> >
> > zzmatch(R_PAR);
> >
> > -
> >
> > - /* MR23 */ if (zzaRet.l != NULL) {
> >
> > +
> >
> > + /* MR23 */ if (zzaRet.l != NULL) {
> >
> > (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
> >
> > if (zzaArg(zztasp1,2 ).r) {
> >
> > (zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r; /* MR20 */
> >
> > @@ -526,7 +526,7 @@ expr()
> > zzmatch(L_BRACE); zzCONSUME;
> >
> > reg_expr();
> >
> > zzmatch(R_BRACE);
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (zzaRet.l != NULL) {
> >
> > (zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
> >
> > (zzaRet.l)->trans[1] = zzaRet.r;
> >
> > @@ -540,7 +540,7 @@ expr()
> > else {
> >
> > if ( (setwd3[LA(1)]&0x1) ) {
> >
> > atom();
> >
> > -
> >
> > +
> >
> > /* MR23 */ if (zzaRet.l != NULL) {
> >
> > (zzaRet.l)->trans[0] = zzaRet.r;
> >
> > (zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
> >
> > @@ -636,7 +636,7 @@ near_atom()
> > int debugLetter1 = zzaRet.letter;
> >
> > int debugLetter2 = zzaArg(zztasp2,2 ).letter;
> >
> > }
> >
> > - if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
> >
> > + if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
> >
> > && zzaArg(zztasp2,2 ).letter != 0xff){ /* MR16 */
> >
> > error("invalid range ", zzline);
> >
> > }
> >
> > @@ -792,7 +792,7 @@ anychar()
> > return;
> >
> > fail:
> >
> > zzEXIT(zztasp1);
> >
> > - /* empty action */
> >
> > + /* empty action */
> >
> > zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
> >
> > zzresynch(setwd3, 0x80);
> >
> > }
> >
> > @@ -808,7 +808,7 @@ new_nfa_node()
> > {
> >
> > register nfa_node *t;
> >
> > static int nfa_size=0; /* elements nfa_array[] can hold */
> >
> > -
> >
> > +
> >
> > ++nfa_allocated;
> >
> > if (nfa_size<=nfa_allocated){
> >
> > /* need to redo array */
> >
> > @@ -879,7 +879,7 @@ set s;
> > #endif
> >
> > {
> >
> > unsigned int *x;
> >
> > -
> >
> > +
> >
> > fprintf(f, "n = %d,", s.n);
> >
> > if (s.setword){
> >
> > fprintf(f, "setword = %x, ", s.setword);
> >
> > @@ -909,7 +909,7 @@ int last_node;
> > {
> >
> > register int i;
> >
> > nfa_node *t;
> >
> > -
> >
> > +
> >
> > for (i=first_node; i<=last_node; ++i){
> >
> > t = NFA(i);
> >
> > if (!t) break;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
> > index 35bd827f8c9e..41ec653b4e97 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
> > @@ -136,7 +136,7 @@ Opt options[] = {
> > { "-o", 1, (WildFunc)p_outdir, OutputDirectoryOption},
> >
> > { "-", 0, (WildFunc)p_stdio, "Use standard i/o rather than file"},
> >
> > { "*", 0, (WildFunc)p_file, ""}, /* anything else is a file */
> >
> > - { NULL, 0, NULL }
> >
> > + { NULL, 0, NULL }
> >
> > };
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > @@ -149,7 +149,7 @@ Opt *options;
> > #endif
> >
> > {
> >
> > Opt *p;
> >
> > -
> >
> > +
> >
> > while ( argc-- > 0 )
> >
> > {
> >
> > p = options;
> >
> > @@ -240,7 +240,7 @@ char *argv[];
> > }
> >
> >
> >
> > /* initialize all the variables */
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > init(void)
> >
> > #else
> >
> > @@ -265,11 +265,11 @@ init()
> > clear_hash();
> >
> > /* NOTE: need to set this flag before the lexer starts getting */
> >
> > /* tokens */
> >
> > - func_action = FALSE;
> >
> > + func_action = FALSE;
> >
> > }
> >
> >
> >
> > /* stuff that needs to be reset when a new automaton is being built */
> >
> > -void
> >
> > +void
> >
> > #ifdef __USE_PROTOS
> >
> > new_automaton_mode(void) /* MR1 */
> >
> > #else
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
> > index b3a34d3b4613..9f79b3fbdd84 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
> > @@ -149,7 +149,7 @@ main.$(OBJ_EXT) : main.c dlg.h
> > set.$(OBJ_EXT) : $(SET)/set.c
> >
> > $(BUILD_CC) -c $(BUILD_CFLAGS) $(SET)/set.c
> >
> >
> >
> > -%.o : %.c
> >
> > +%.o : %.c
> >
> > $(BUILD_CC) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $< -o $@
> >
> >
> >
> > lint:
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
> > index 2e56a6d8c190..0366ea67e69f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
> > @@ -143,7 +143,7 @@ char *s;
> > #ifdef __USE_PROTOS
> >
> > void p_class_hdr(void)
> >
> > #else
> >
> > -void p_class_hdr()
> >
> > +void p_class_hdr()
> >
> > #endif
> >
> > {
> >
> > if ( class_stream == NULL ) return;
> >
> > @@ -845,6 +845,6 @@ set label;
> > printf("\n");
> >
> > free(t);
> >
> > }
> >
> > -
> >
> > +
> >
> > }
> >
> > #endif
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
> > index f2dce30f5fe5..94906f3887a5 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
> > @@ -67,7 +67,7 @@ nfa_node *start;
> > #endif
> >
> > {
> >
> > if (level){
> >
> > - set_free(used_classes);
> >
> > + set_free(used_classes);
> >
> > partition(start,level);
> >
> > label_with_classes(start);
> >
> > }else{
> >
> > @@ -146,7 +146,7 @@ set *maximal_class;
> > {
> >
> > /* pick a new operation number */
> >
> > ++operation_no;
> >
> > - r_intersect(start,maximal_class);
> >
> > + r_intersect(start,maximal_class);
> >
> > }
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
> > index 84fe99d69cb8..83665402587a 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
> > @@ -211,7 +211,7 @@ char *OutMetaName(char *n)
> > char *OutMetaName(n)
> >
> > char *n;
> >
> > #endif
> >
> > -{
> >
> > +{
> >
> > static char *dir_sym = DirectorySymbol;
> >
> > static char newname[MaxFileName+1];
> >
> > char *p;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
> > index 720fe75af1d7..d54e9db2098f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
> > @@ -400,7 +400,7 @@ resynch(SetWordType *wd,SetWordType mask)
> > /* if current token is in resynch set, we've got what we wanted */
> >
> >
> >
> > /* MR8 */ if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;}
> >
> > -
> >
> > +
> >
> > /* scan until we find something in the resynch set */
> >
> >
> >
> > while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();}
> >
> > @@ -419,7 +419,7 @@ resynch(SetWordType *wd,SetWordType mask)
> > returns the text, so the text representation of the token
> >
> > must be passed explicitly. I think.
> >
> > */
> >
> > -
> >
> > +
> >
> > void ANTLRParser::
> >
> > syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset,
> >
> > ANTLRTokenType etok, int k)
> >
> > @@ -432,7 +432,7 @@ syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset,
> >
> >
> > /* MR23 If the token is not an EOF token, then use the ->getText() value.
> >
> >
> >
> > - If the token is the EOF token the text returned by ->getText()
> >
> > + If the token is the EOF token the text returned by ->getText()
> >
> > may be garbage. If the text from the token table is "@" use
> >
> > "<eof>" instead, because end-users don't know what "@" means.
> >
> > If the text is not "@" then use that text, which must have been
> >
> > @@ -526,7 +526,7 @@ void
> > ANTLRParser::FAIL(int k, ...)
> >
> > {
> >
> > //
> >
> > -// MR1 10-Apr-97
> >
> > +// MR1 10-Apr-97
> >
> > //
> >
> >
> >
> > if (zzFAILtext == NULL) zzFAILtext=new char [1000]; // MR9
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
> > index fe405f416770..9b833a13cc46 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
> > @@ -228,7 +228,7 @@ public:
> > virtual ~ANTLRParser();
> >
> >
> >
> > virtual void init();
> >
> > -
> >
> > +
> >
> > ANTLRTokenType LA(int i)
> >
> > {
> >
> > //
> >
> > @@ -274,7 +274,7 @@ public:
> > SetWordType *whatFollows);
> >
> > virtual int _match_wdfltsig(ANTLRTokenType tokenWanted,
> >
> > SetWordType *whatFollows);
> >
> > -
> >
> > +
> >
> > const ANTLRChar * parserTokenName(int tok); // MR1
> >
> >
> >
> > int traceOptionValueDefault; // MR11
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
> > index a94f080c8671..af1737dd2a84 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
> > @@ -90,7 +90,7 @@ ASTBase::preorder(void* pData /*= NULL*/ /* MR23 */)
> > while ( tree!= NULL )
> >
> > {
> >
> > if ( tree->_down != NULL ) {
> >
> > - tree->preorder_before_action(pData); // MR1
> >
> > + tree->preorder_before_action(pData); // MR1
> >
> > };
> >
> > tree->preorder_action(pData);
> >
> > if ( tree->_down!=NULL )
> >
> > @@ -136,7 +136,7 @@ ASTBase::tmake(ASTBase *root, ...)
> > va_start(ap, root);
> >
> >
> >
> > if ( root != NULL )
> >
> > - if ( root->_down != NULL ) {
> >
> > + if ( root->_down != NULL ) {
> >
> > root->reportOverwriteOfDownPointer(); /* MR21 Report problem which almost always an error */
> >
> > return NULL;
> >
> > }
> >
> > @@ -162,7 +162,7 @@ ASTBase *
> > ASTBase::dup()
> >
> > {
> >
> > ASTBase *u, *t=this;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return NULL;
> >
> > /*
> >
> > u = new ASTBase;
> >
> > @@ -189,7 +189,7 @@ ASTBase *
> > ASTDoublyLinkedBase::dup()
> >
> > {
> >
> > ASTDoublyLinkedBase *u, *t=this;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return NULL;
> >
> > u = (ASTDoublyLinkedBase *)this->shallowCopy();
> >
> > u->_up = NULL; /* set by calling invocation */
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
> > index 9a2f2fc88b81..9c1c3c20990b 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
> > @@ -340,12 +340,12 @@ getParser() { // MR1
> > } // MR1
> >
> >
> >
> > void ANTLRTokenBuffer::panic(const char *msg) // MR23
> >
> > -{
> >
> > +{
> >
> > if (parser) //MR23
> >
> > parser->panic(msg); //MR23
> >
> > else //MR23
> >
> > - exit(PCCTS_EXIT_FAILURE);
> >
> > -}
> >
> > + exit(PCCTS_EXIT_FAILURE);
> >
> > +}
> >
> >
> >
> > //MR23
> >
> > int ANTLRTokenBuffer::printMessage(FILE* pFile, const char* pFormat, ...)
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
> > index f3b4b79e8a8b..e80afce946fc 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
> > @@ -38,24 +38,24 @@ template <
> > class DLG_stream_input : public DLGInputStream
> >
> > {
> >
> > public:
> >
> > -
> >
> > +
> >
> > DLG_stream_input(::std::basic_istream<E,T> * p_input_stream)
> >
> > : input(p_input_stream)
> >
> > {
> >
> > // nothing to do!
> >
> > };
> >
> > -
> >
> > +
> >
> > DLG_stream_input(const DLG_stream_input & a_recopier)
> >
> > : input(a_recopier.input)
> >
> > {
> >
> > // nothing to do!
> >
> > };
> >
> > -
> >
> > +
> >
> > virtual ~DLG_stream_input()
> >
> > {
> >
> > this->purge(); // bloody templarized lookup...
> >
> > };
> >
> > -
> >
> > +
> >
> > DLG_stream_input operator = (const DLG_stream_input & a_affecter)
> >
> > {
> >
> > if (this != &a_affecter)
> >
> > @@ -65,13 +65,13 @@ public:
> >
> >
> > return(*this);
> >
> > };
> >
> > -
> >
> > +
> >
> > virtual int nextChar()
> >
> > {
> >
> > E extracted_stuff;
> >
> > -
> >
> > +
> >
> > input->get(extracted_stuff);
> >
> > -
> >
> > +
> >
> > if (*input)
> >
> > {
> >
> > return(int(extracted_stuff));
> >
> > @@ -81,13 +81,13 @@ public:
> > return(EOF);
> >
> > }
> >
> > };
> >
> > -
> >
> > +
> >
> > protected:
> >
> > -
> >
> > +
> >
> > ::std::basic_istream<E,T> * input;
> >
> > -
> >
> > +
> >
> > private:
> >
> > -
> >
> > +
> >
> > void purge()
> >
> > {
> >
> > // nothing to do!
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
> > index b218afc03811..2ade02c3ccde 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
> > @@ -83,7 +83,7 @@ DLGLexerBase(DLGInputStream *in,
> > this->lexErrCount=0; // MR11
> >
> > }
> >
> >
> >
> > -// MR19 THM
> >
> > +// MR19 THM
> >
> >
> >
> > void DLGLexerBase::reset()
> >
> > {
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
> > index d25b8d69392c..8532f8fa72a0 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
> > @@ -55,7 +55,7 @@ private:
> >
> >
> > // no copy assignment allowed
> >
> > ParserBlackBox & operator=(ParserBlackBox const &);
> >
> > -
> >
> > +
> >
> > protected:
> >
> > DLGFileInput *in;
> >
> > Lexer *scan;
> >
> > @@ -65,7 +65,7 @@ protected:
> > FILE *file;
> >
> > int openByBlackBox; /* MR21 Don't close what we haven't opened */
> >
> > public:
> >
> > -
> >
> > +
> >
> > ParserBlackBox(FILE *f)
> >
> > : in(0)
> >
> > , scan(0)
> >
> > @@ -77,7 +77,7 @@ public:
> > {
> >
> > if (f == NULL)
> >
> > {
> >
> > - cerr << "invalid file pointer\n";
> >
> > + cerr << "invalid file pointer\n";
> >
> > }
> >
> > else
> >
> > {
> >
> > @@ -118,7 +118,7 @@ public:
> > _parser->init();
> >
> > }
> >
> > }
> >
> > -
> >
> > +
> >
> > ~ParserBlackBox()
> >
> > {
> >
> > delete in; delete scan; delete pipe; delete _parser; delete tok;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
> > index a8249cdac0a2..9d708e945ff9 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
> > @@ -270,11 +270,11 @@ scanmatch(ScanAST *t, PCCTS_AST **labels[], int *n)
> > /* match what's below if something there and current node is not wildcard */
> >
> > if ( sib->down()!=NULL && sib->type()!=0 )
> >
> > {
> >
> > - if ( sib->down()==NULL )
> >
> > + if ( sib->down()==NULL )
> >
> > {
> >
> > - if ( u->down()!=NULL )
> >
> > - return 0;
> >
> > - else
> >
> > + if ( u->down()!=NULL )
> >
> > + return 0;
> >
> > + else
> >
> > return 1;
> >
> > }
> >
> > if ( !u->down()->scanmatch(sib->down(), labels, n) ) return 0;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
> > index 27a324274257..ea3d2a42cd6c 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
> > @@ -1,4 +1,4 @@
> > -/* antlr.h
> >
> > +/* antlr.h
> >
> > *
> >
> > * SOFTWARE RIGHTS
> >
> > *
> >
> > @@ -353,7 +353,7 @@ extern void _inf_zzgettok();
> > InfLookData \
> >
> > zzGuessData
> >
> > #endif
> >
> > -
> >
> > +
> >
> > #endif /* LL_k */
> >
> >
> >
> >
> >
> > @@ -461,7 +461,7 @@ extern void _inf_zzgettok();
> > zzEXIT_ANTLR(zztasp1 + 1); \
> >
> > } \
> >
> > zzleaveANTLR(f);
> >
> > -
> >
> > +
> >
> > #define ANTLRm(st, f, _m) zzbufsize = ZZLEXBUFSIZE; \
> >
> > zzmode(_m); \
> >
> > zzenterANTLR(f); \
> >
> > @@ -473,7 +473,7 @@ extern void _inf_zzgettok();
> > zzEXIT_ANTLR(zztasp1 + 1); \
> >
> > } \
> >
> > zzleaveANTLR(f);
> >
> > -
> >
> > +
> >
> > #define ANTLRf(st, f) zzbufsize = ZZLEXBUFSIZE; \
> >
> > zzenterANTLRf(f); \
> >
> > { \
> >
> > @@ -535,7 +535,7 @@ extern void _inf_zzgettok();
> > #endif
> >
> >
> >
> > #ifdef __USE_PROTOS
> >
> > -extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
> >
> > +extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
> >
> > extern int _zzsetmatch_wsig(SetWordType *);
> >
> > #else
> >
> > extern int _zzsetmatch();
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
> > index 9326ae16ae75..f22c0523f28e 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
> > @@ -18,7 +18,7 @@
> > * addition, we ask that this header remain intact in our source code.
> >
> > * As long as these guidelines are kept, we expect to continue enhancing
> >
> > * this system and expect to make other tools available as they are
> >
> > - * completed.
> >
> > + * completed.
> >
> > *
> >
> > * ANTLR 1.33
> >
> > * Terence Parr
> >
> > @@ -292,7 +292,7 @@ AST *t;
> > #endif
> >
> > {
> >
> > AST *u;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return NULL;
> >
> > u = zzastnew();
> >
> > *u = *t;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/err.h b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
> > index 435d48356d5a..cd24f46db67c 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
> > @@ -106,7 +106,7 @@ SetWordType *wd, mask;
> >
> >
> > /* if current token is in resynch set, we've got what we wanted */
> >
> > if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
> >
> > -
> >
> > +
> >
> > /* scan until we find something in the resynch set */
> >
> > while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
> >
> > consumed=1;
> >
> > @@ -427,7 +427,7 @@ int k;
> > SetWordType *eset;
> >
> > #endif
> >
> > {
> >
> > -
> >
> > +
> >
> > zzSyntaxErrCount++; /* MR11 */
> >
> > fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
> >
> > if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
> >
> > @@ -508,14 +508,14 @@ SetWordType **zzMissSet;
> > zzCONSUME;
> >
> > }
> >
> > if ( LA(1)!=_t ) {
> >
> > - *zzBadText = *zzMissText=LATEXT(1);
> >
> > + *zzBadText = *zzMissText=LATEXT(1);
> >
> > *zzMissTok= _t; *zzBadTok=LA(1);
> >
> > - *zzMissSet=NULL;
> >
> > + *zzMissSet=NULL;
> >
> > return 0;
> >
> > }
> >
> > - zzMakeAttr
> >
> > - zzdirty++;
> >
> > - zzlabase++;
> >
> > + zzMakeAttr
> >
> > + zzdirty++;
> >
> > + zzlabase++;
> >
> > return 1;
> >
> > }
> >
> >
> >
> > @@ -533,9 +533,9 @@ int _t;
> > if ( LA(1)!=_t ) {
> >
> > return 0;
> >
> > }
> >
> > - zzMakeAttr
> >
> > - zzdirty++;
> >
> > - zzlabase++;
> >
> > + zzMakeAttr
> >
> > + zzdirty++;
> >
> > + zzlabase++;
> >
> > return 1;
> >
> > }
> >
> >
> >
> > @@ -553,16 +553,16 @@ char **zzMissText;
> > int *zzMissTok, *zzBadTok;
> >
> > SetWordType **zzMissSet;
> >
> > #endif
> >
> > -{
> >
> > - if ( zzdirty ) {zzCONSUME;}
> >
> > +{
> >
> > + if ( zzdirty ) {zzCONSUME;}
> >
> > if ( LA(1)!=_t ) {
> >
> > - *zzBadText = *zzMissText=LATEXT(1);
> >
> > + *zzBadText = *zzMissText=LATEXT(1);
> >
> > *zzMissTok= _t; *zzBadTok=LA(1);
> >
> > - *zzMissSet=NULL;
> >
> > + *zzMissSet=NULL;
> >
> > return 0;
> >
> > - }
> >
> > - zzdirty = 1;
> >
> > - zzMakeAttr
> >
> > + }
> >
> > + zzdirty = 1;
> >
> > + zzMakeAttr
> >
> > return 1;
> >
> > }
> >
> >
> >
> > @@ -574,12 +574,12 @@ _zzmatch_wsig(_t)
> > int _t;
> >
> > #endif
> >
> > {
> >
> > - if ( zzdirty ) {zzCONSUME;}
> >
> > + if ( zzdirty ) {zzCONSUME;}
> >
> > if ( LA(1)!=_t ) {
> >
> > return 0;
> >
> > }
> >
> > - zzdirty = 1;
> >
> > - zzMakeAttr
> >
> > + zzdirty = 1;
> >
> > + zzMakeAttr
> >
> > return 1;
> >
> > }
> >
> >
> >
> > @@ -601,10 +601,10 @@ int *zzMissTok, *zzBadTok;
> > SetWordType **zzMissSet;
> >
> > #endif
> >
> > {
> >
> > - if ( LA(1)!=_t ) {
> >
> > - *zzBadText = *zzMissText=LATEXT(1);
> >
> > + if ( LA(1)!=_t ) {
> >
> > + *zzBadText = *zzMissText=LATEXT(1);
> >
> > *zzMissTok= _t; *zzBadTok=LA(1);
> >
> > - *zzMissSet=NULL;
> >
> > + *zzMissSet=NULL;
> >
> > return 0;
> >
> > }
> >
> > zzMakeAttr
> >
> > @@ -620,7 +620,7 @@ int _t;
> > #endif
> >
> > {
> >
> > if ( LA(1)!=_t ) return 0;
> >
> > - zzMakeAttr
> >
> > + zzMakeAttr
> >
> > return 1;
> >
> > }
> >
> >
> >
> > @@ -634,14 +634,14 @@ _inf_zzgettok(void)
> > _inf_zzgettok()
> >
> > #endif
> >
> > {
> >
> > - if ( zzinf_labase >= zzinf_last )
> >
> > - {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
> >
> > - else {
> >
> > + if ( zzinf_labase >= zzinf_last )
> >
> > + {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
> >
> > + else {
> >
> > NLA = zzinf_tokens[zzinf_labase];
> >
> > zzline = zzinf_line[zzinf_labase]; /* wrong in 1.21 */
> >
> > - strcpy(NLATEXT, zzinf_text[zzinf_labase]);
> >
> > - zzinf_labase++;
> >
> > - }
> >
> > + strcpy(NLATEXT, zzinf_text[zzinf_labase]);
> >
> > + zzinf_labase++;
> >
> > + }
> >
> > }
> >
> > #endif
> >
> >
> >
> > @@ -670,14 +670,14 @@ zzfill_inf_look()
> > {
> >
> > fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
> >
> > zzinf_text_buffer_size);
> >
> > - exit(PCCTS_EXIT_FAILURE);
> >
> > + exit(PCCTS_EXIT_FAILURE);
> >
> > }
> >
> > zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
> >
> > if ( zzinf_tokens == NULL )
> >
> > {
> >
> > fprintf(stderr, "cannot allocate token buffer (%d tokens)\n",
> >
> > zzinf_token_buffer_size);
> >
> > - exit(PCCTS_EXIT_FAILURE);
> >
> > + exit(PCCTS_EXIT_FAILURE);
> >
> > }
> >
> > zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
> >
> > if ( zzinf_line == NULL )
> >
> > @@ -741,8 +741,8 @@ zzfill_inf_look()
> > {
> >
> > fprintf(stderr, "cannot allocate lookahead text buffer (%d)\n",
> >
> > zzinf_text_buffer_size);
> >
> > - exit(PCCTS_EXIT_FAILURE);
> >
> > - }
> >
> > + exit(PCCTS_EXIT_FAILURE);
> >
> > + }
> >
> > zzinf_text_buffer_index = 0;
> >
> > zzinf_lap = 0;
> >
> > /* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
> >
> > @@ -826,7 +826,7 @@ SetWordType *whatFollows;
> > return 0;
> >
> > }
> >
> > else {
> >
> > - zzMakeAttr
> >
> > + zzMakeAttr
> >
> > #ifdef DEMAND_LOOK
> >
> > #ifdef LL_K
> >
> > zzdirty++;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/history.txt b/BaseTools/Source/C/VfrCompile/Pccts/history.txt
> > index 89ad8408c93d..84bfeb06ee7a 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/history.txt
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/history.txt
> > @@ -59,7 +59,7 @@ kahead fetches were to occur only when necessary for the parse
> >
> >
> >
> >
> > Page 1
> >
> > -
> >
> >
> >
> > +
> >
> > PCCTS
> >
> >
> >
> >
> >
> > @@ -121,7 +121,7 @@ called "parser exception handling" in a near future release.
> >
> >
> >
> >
> > Page 2
> >
> > -
> >
> >
> >
> > +
> >
> > PCCTS
> >
> >
> >
> >
> >
> > @@ -183,4 +183,4 @@ _____________________________________________________________________________
> >
> >
> >
> >
> > Page 3
> >
> > -
> >
> >
> >
> > +
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
> > b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
> > index 4952a30b3883..a37ba7450405 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
> > @@ -193,7 +193,7 @@ char *t;
> > pSor(NULL);
> >
> > warn("sorcerer input file before any '-sor' option");
> >
> > }
> >
> > -
> >
> > +
> >
> > require(num_sfiles[num_sors-1]<MAX_SFILES,
> >
> > "exceeded max # of sorcerer input files");
> >
> > sfiles[num_sors-1][num_sfiles[num_sors-1]++] = t;
> >
> > @@ -378,10 +378,10 @@ char **argv;
> > #endif
> >
> > {
> >
> > int i;
> >
> > -
> >
> > +
> >
> > if ( argc == 1 ) { help(); DIE; }
> >
> > for(i=0;i<MAX_SORS;i++) num_sfiles[i]=0;
> >
> > -
> >
> > +
> >
> > ProcessArgs(argc-1, &(argv[1]), options);
> >
> >
> >
> > strcpy(ATOKENBUFFER_O, ATOKENBUFFER_C);
> >
> > @@ -476,7 +476,7 @@ char **argv;
> > else printf("# ANTLR-defined token types\n");
> >
> > printf("#\n");
> >
> > /***********
> >
> > - printf(".SUFFIXES:\n.SUFFIXES:\t.o .cpp .c .h .g .i .dlg .sor\n");
> >
> > + printf(".SUFFIXES:\n.SUFFIXES:\t.o .cpp .c .h .g .i .dlg .sor\n");
> >
> > ***********/
> >
> > if ( user_token_types!=NULL ) {
> >
> > printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
> >
> > @@ -821,7 +821,7 @@ char **argv;
> > pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
> >
> > printf(" ");
> >
> > pclasses(&sclasses[i], 1, "h");
> >
> > - if ( strcmp(hdr,"stdpccts.h")!=0 )
> >
> > + if ( strcmp(hdr,"stdpccts.h")!=0 )
> >
> > {
> >
> > printf(" ");
> >
> > printf("$(HDR_FILE) stdpccts.h");
> >
> > @@ -842,7 +842,7 @@ char **argv;
> > printf("STreeParser%s ",OBJ_FILE_SUFFIX);
> >
> > printf("$(SOR_LIB)%sSTreeParser.cpp\n\n",DirectorySymbol);
> >
> > }
> >
> > -
> >
> > +
> >
> > printf("$(ANTLR_SPAWN) : $(GRM)\n");
> >
> > printf("\t$(ANTLR) $(AFLAGS) $(GRM)\n");
> >
> >
> >
> > @@ -1056,7 +1056,7 @@ char *DIR()
> > #endif
> >
> > {
> >
> > static char buf[200+1];
> >
> > -
> >
> > +
> >
> > if ( strcmp(outdir,TopDirectory)==0 ) return "";
> >
> > sprintf(buf, "%s%s", outdir, DirectorySymbol);
> >
> > return buf;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
> > b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
> > index 2cf9fad72701..ef36f0888a6a 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
> > @@ -341,7 +341,7 @@ char **argv;
> > if ( user_token_types!=NULL ) printf("# User-defined token types in '%s'\n", user_token_types);
> >
> > else printf("# ANTLR-defined token types\n");
> >
> > printf("#\n");
> >
> > - printf(".SUFFIXES:\n.SUFFIXES: .o .cpp .c .h .g .i .dlg\n");
> >
> > + printf(".SUFFIXES:\n.SUFFIXES: .o .cpp .c .h .g .i .dlg\n");
> >
> > if ( user_token_types!=NULL ) {
> >
> > printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
> >
> > printf("TOKENS = %s", user_token_types);
> >
> > @@ -755,7 +755,7 @@ char *err_;
> > char *DIR()
> >
> > {
> >
> > static char buf[200+1];
> >
> > -
> >
> > +
> >
> > if ( strcmp(outdir,TopDirectory)==0 ) return "";
> >
> > sprintf(buf, "%s%s", outdir, DirectorySymbol);
> >
> > return buf;
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
> > index 805bf655331b..0fdb75a5e54f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
> > @@ -154,7 +154,7 @@ char *s;
> > #endif
> >
> > {
> >
> > ArcPtr p;
> >
> > -
> >
> > +
> >
> > if ( automaton == accept && *s == '\0' ) return 1; /* match */
> >
> >
> >
> > for (p=automaton->arcs; p!=NULL; p=p->next) /* try all arcs */
> >
> > @@ -185,12 +185,12 @@ GraphPtr g;
> > #endif
> >
> > {
> >
> > Graph g1, g2;
> >
> > -
> >
> > +
> >
> > if ( andExpr(&g1) == -1 )
> >
> > {
> >
> > return -1;
> >
> > }
> >
> > -
> >
> > +
> >
> > while ( token == '|' )
> >
> > {
> >
> > int a;
> >
> > @@ -200,7 +200,7 @@ GraphPtr g;
> > else if ( !a ) return 1; /* empty alternative */
> >
> > g1 = BuildNFA_AorB(g1, g2);
> >
> > }
> >
> > -
> >
> > +
> >
> > if ( token!='\0' ) return -1;
> >
> >
> >
> > *g = g1;
> >
> > @@ -219,18 +219,18 @@ GraphPtr g;
> > #endif
> >
> > {
> >
> > Graph g1, g2;
> >
> > -
> >
> > +
> >
> > if ( expr(&g1) == -1 )
> >
> > {
> >
> > return -1;
> >
> > }
> >
> > -
> >
> > +
> >
> > while ( token==Atom || token=='{' || token=='(' || token=='~' || token=='[' )
> >
> > {
> >
> > if (expr(&g2) == -1) return -1;
> >
> > g1 = BuildNFA_AB(g1, g2);
> >
> > }
> >
> > -
> >
> > +
> >
> > *g = g1;
> >
> > return 1;
> >
> > }
> >
> > @@ -251,7 +251,7 @@ GraphPtr g;
> > {
> >
> > int complement = 0;
> >
> > char s[257]; /* alloc space for string of char in [] */
> >
> > -
> >
> > +
> >
> > if ( token == '~' || token == '[' )
> >
> > {
> >
> > if ( token == '~' ) {complement = 1; next();}
> >
> > @@ -294,7 +294,7 @@ GraphPtr g;
> > repeatSymbol( g );
> >
> > return 1;
> >
> > }
> >
> > -
> >
> > +
> >
> > return -1;
> >
> > }
> >
> >
> >
> > @@ -335,9 +335,9 @@ int complement;
> > static unsigned char set[256]; /* no duplicates */
> >
> > int first, last, i;
> >
> > char *s = p;
> >
> > -
> >
> > +
> >
> > if ( token != Atom ) return -1;
> >
> > -
> >
> > +
> >
> > for (i=0; i<256; i++) set[i] = 0;
> >
> > while ( token == Atom )
> >
> > {
> >
> > @@ -458,7 +458,7 @@ int label;
> > #endif
> >
> > {
> >
> > ArcPtr a;
> >
> > -
> >
> > +
> >
> > a = newGraphArc();
> >
> > if ( i->arcs == NULL ) i->arctail = i->arcs = a;
> >
> > else {(i->arctail)->next = a; i->arctail = a;}
> >
> > @@ -474,7 +474,7 @@ int label;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > g.left = newNode();
> >
> > g.right = newNode();
> >
> > ArcBetweenGraphNodes(g.left, g.right, label);
> >
> > @@ -489,7 +489,7 @@ Graph A, B;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > ArcBetweenGraphNodes(A.right, B.left, Epsilon);
> >
> > g.left = A.left;
> >
> > g.right = B.right;
> >
> > @@ -504,7 +504,7 @@ Graph A, B;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > g.left = newNode();
> >
> > ArcBetweenGraphNodes(g.left, A.left, Epsilon);
> >
> > ArcBetweenGraphNodes(g.left, B.left, Epsilon);
> >
> > @@ -522,9 +522,9 @@ char *s;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > if ( s == NULL ) return g;
> >
> > -
> >
> > +
> >
> > g.left = newNode();
> >
> > g.right = newNode();
> >
> > while ( *s != '\0' )
> >
> > @@ -545,12 +545,12 @@ Graph A;
> >
> >
> > g.left = newNode();
> >
> > g.right = newNode();
> >
> > -
> >
> > +
> >
> > ArcBetweenGraphNodes(g.left, A.left, Epsilon);
> >
> > ArcBetweenGraphNodes(g.left, g.right, Epsilon);
> >
> > ArcBetweenGraphNodes(A.right, g.right, Epsilon);
> >
> > ArcBetweenGraphNodes(A.right, A.left, Epsilon);
> >
> > -
> >
> > +
> >
> > return( g );
> >
> > }
> >
> >
> >
> > @@ -562,7 +562,7 @@ Graph A;
> > #endif
> >
> > {
> >
> > ArcBetweenGraphNodes(A.right, A.left, Epsilon);
> >
> > -
> >
> > +
> >
> > return( A );
> >
> > }
> >
> >
> >
> > @@ -574,13 +574,13 @@ Graph A;
> > #endif
> >
> > {
> >
> > Graph g;
> >
> > -
> >
> > +
> >
> > g.left = newNode();
> >
> > g.right = newNode();
> >
> > -
> >
> > +
> >
> > ArcBetweenGraphNodes(g.left, A.left, Epsilon);
> >
> > ArcBetweenGraphNodes(g.left, g.right, Epsilon);
> >
> > ArcBetweenGraphNodes(A.right, g.right, Epsilon);
> >
> > -
> >
> > +
> >
> > return( g );
> >
> > }
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
> > index 6b9b510b8aed..44d6ee44c3ce 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
> > @@ -2,37 +2,37 @@
> >
> >
> > The following is a general-purpose set library originally developed
> >
> > by Hank Dietz and enhanced by Terence Parr to allow dynamic sets.
> >
> > -
> >
> > +
> >
> > Sets are now structs containing the #words in the set and
> >
> > a pointer to the actual set words.
> >
> > -
> >
> > +
> >
> > Generally, sets need not be explicitly allocated. They are
> >
> > created/extended/shrunk when appropriate (e.g. in set_of()).
> >
> > HOWEVER, sets need to be destroyed (free()ed) when they go out of scope
> >
> > or are otherwise no longer needed. A routine is provided to
> >
> > free a set.
> >
> > -
> >
> > +
> >
> > Sets can be explicitly created with set_new(s, max_elem).
> >
> > -
> >
> > +
> >
> > Sets can be declared to have minimum size to reduce realloc traffic.
> >
> > Default minimum size = 1.
> >
> > -
> >
> > +
> >
> > Sets can be explicitly initialized to have no elements (set.n == 0)
> >
> > by using the 'empty' initializer:
> >
> > -
> >
> > +
> >
> > Examples:
> >
> > set a = empty; -- set_deg(a) == 0
> >
> > -
> >
> > +
> >
> > return( empty );
> >
> > -
> >
> > +
> >
> > Example set creation and destruction:
> >
> > -
> >
> > +
> >
> > set
> >
> > set_of2(e,g)
> >
> > unsigned e,g;
> >
> > {
> >
> > set a,b,c;
> >
> > -
> >
> > +
> >
> > b = set_of(e); -- Creates space for b and sticks in e
> >
> > set_new(c, g); -- set_new(); set_orel() ==> set_of()
> >
> > set_orel(g, &c);
> >
> > @@ -46,7 +46,7 @@
> > }
> >
> >
> >
> > 1987 by Hank Dietz
> >
> > -
> >
> > +
> >
> > Modified by:
> >
> > Terence Parr
> >
> > Purdue University
> >
> > @@ -170,7 +170,7 @@ set c;
> > q = c.setword;
> >
> > p = b.setword;
> >
> > endp = &(b.setword[n]);
> >
> > - while ( p < endp ) *r++ = *p++ | *q++;
> >
> > + while ( p < endp ) *r++ = *p++ | *q++;
> >
> >
> >
> > /* Copy rest of bigger set into result */
> >
> > p = &(big->setword[n]);
> >
> > @@ -206,7 +206,7 @@ set c;
> > q = c.setword;
> >
> > p = b.setword;
> >
> > endp = &(b.setword[n]);
> >
> > - while ( p < endp ) *r++ = *p++ & *q++;
> >
> > + while ( p < endp ) *r++ = *p++ & *q++;
> >
> >
> >
> > return(t);
> >
> > }
> >
> > @@ -238,7 +238,7 @@ set c;
> > q = c.setword;
> >
> > p = b.setword;
> >
> > endp = &(b.setword[n]);
> >
> > - while ( p < endp ) *r++ = *p++ & (~ *q++);
> >
> > + while ( p < endp ) *r++ = *p++ & (~ *q++);
> >
> >
> >
> > /* Copy rest of b into result if size(b) > c */
> >
> > if ( b.n > n )
> >
> > @@ -289,7 +289,7 @@ unsigned int n;
> > register unsigned *p;
> >
> > register unsigned *endp;
> >
> > unsigned int size;
> >
> > -
> >
> > +
> >
> > CHK((*a));
> >
> > if ( a->n == 0 )
> >
> > {
> >
> > @@ -345,7 +345,7 @@ set a;
> > if ( a.n == 0 ) return( empty );
> >
> > set_ext(&t, a.n);
> >
> > r = t.setword;
> >
> > -
> >
> > +
> >
> > do {
> >
> > *r++ = (~ *p++);
> >
> > } while ( p < endp );
> >
> > @@ -470,7 +470,7 @@ set a;
> > /* nil is an element of every set */
> >
> > if (b == nil) return(1);
> >
> > if ( a.n == 0 || NumWords(b) > a.n ) return(0);
> >
> > -
> >
> > +
> >
> > /* Otherwise, we have to check */
> >
> > return( a.setword[DIVWORD(b)] & bitmask[MODWORD(b)] );
> >
> > }
> >
> > @@ -490,7 +490,7 @@ set a;
> > CHK(a);
> >
> > if ( a.n == 0 ) return(1);
> >
> > endp = &(a.setword[a.n]);
> >
> > -
> >
> > +
> >
> > /* The set is not empty if any word used to store
> >
> > the set is non-zero. This means one must be a
> >
> > bit careful about doing things like negation.
> >
> > @@ -498,7 +498,7 @@ set a;
> > do {
> >
> > if (*p) return(0);
> >
> > } while (++p < endp);
> >
> > -
> >
> > +
> >
> > return(1);
> >
> > }
> >
> >
> >
> > @@ -678,7 +678,7 @@ set a;
> > /* Does not effect size of set */
> >
> > register unsigned *p = a.setword;
> >
> > register unsigned *endp;
> >
> > -
> >
> > +
> >
> > CHK(a);
> >
> > if ( a.n == 0 ) return;
> >
> > endp = &(a.setword[a.n]);
> >
> > @@ -699,7 +699,7 @@ set a;
> > register unsigned *p,
> >
> > *q = a.setword,
> >
> > *endq; /* MR20 */
> >
> > -
> >
> > +
> >
> > CHK(a);
> >
> > b = empty;
> >
> > if ( a.n == 0 ) return( empty );
> >
> > @@ -709,7 +709,7 @@ set a;
> > do {
> >
> > *p++ = *q++;
> >
> > } while ( q < endq );
> >
> > -
> >
> > +
> >
> > return(b);
> >
> > }
> >
> >
> >
> > @@ -779,7 +779,7 @@ set a;
> > {
> >
> > unsigned *q;
> >
> > int max_deg;
> >
> > -
> >
> > +
> >
> > CHK(a);
> >
> > max_deg = WORDSIZE*a.n;
> >
> > /* assume a.n!=0 & no elements is rare, but still ok */
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h
> > index 5d68152df4ab..8db773133b7f 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h
> > @@ -5,12 +5,12 @@
> >
> >
> > The following is a general-purpose set library originally developed
> >
> > by Hank Dietz and enhanced by Terence Parr to allow dynamic sets.
> >
> > -
> >
> > +
> >
> > Sets are now structs containing the #words in the set and
> >
> > a pointer to the actual set words.
> >
> >
> >
> > 1987 by Hank Dietz
> >
> > -
> >
> > +
> >
> > Modified by:
> >
> > Terence Parr
> >
> > Purdue University
> >
> > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c
> > index eccce059bb98..98a703c5e746 100644
> > --- a/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c
> > +++ b/BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c
> > @@ -70,18 +70,18 @@
> > * main()
> >
> > * {
> >
> > * Sym *scope1=NULL, *scope2=NULL, *a, *p;
> >
> > - *
> >
> > + *
> >
> > * zzs_init(101, 100);
> >
> > - *
> >
> > + *
> >
> > * a = zzs_new("Apple"); zzs_add(a->symbol, a); -- No scope
> >
> > * zzs_scope( &scope1 ); -- enter scope 1
> >
> > * a = zzs_new("Plum"); zzs_add(a->symbol, a);
> >
> > * zzs_scope( &scope2 ); -- enter scope 2
> >
> > * a = zzs_new("Truck"); zzs_add(a->symbol, a);
> >
> > - *
> >
> > + *
> >
> > * p = zzs_get("Plum");
> >
> > * if ( p == NULL ) fprintf(stderr, "Hmmm...Can't find 'Plum'\n");
> >
> > - *
> >
> > + *
> >
> > * p = zzs_rmscope(&scope1)
> >
> > * for (; p!=NULL; p=p->scope) {printf("Scope1: %s\n", p->symbol);}
> >
> > * p = zzs_rmscope(&scope2)
> >
> > @@ -170,11 +170,11 @@ register Sym *rec;
> > {
> >
> > register unsigned int h=0;
> >
> > register char *p=key;
> >
> > -
> >
> > +
> >
> > HASH(p, h);
> >
> > rec->hash = h; /* save hash code for fast comp later */
> >
> > h %= size;
> >
> > -
> >
> > +
> >
> > if ( CurScope != NULL ) {rec->scope = *CurScope; *CurScope = rec;}
> >
> > rec->next = table[h]; /* Add to doubly-linked list */
> >
> > rec->prev = NULL;
> >
> > @@ -193,9 +193,9 @@ char *key;
> > register unsigned int h=0;
> >
> > register char *p=key;
> >
> > register Sym *q;
> >
> > -
> >
> > +
> >
> > HASH(p, h);
> >
> > -
> >
> > +
> >
> > for (q = table[h%size]; q != NULL; q = q->next)
> >
> > {
> >
> > if ( q->hash == h ) /* do we even have a chance of matching? */
> >
> > @@ -224,7 +224,7 @@ register Sym *p;
> > if ( p->prev == NULL ) /* Head of list */
> >
> > {
> >
> > register Sym **t = p->head;
> >
> > -
> >
> > +
> >
> > if ( t == NULL ) return; /* not part of symbol table */
> >
> > (*t) = p->next;
> >
> > if ( (*t) != NULL ) (*t)->prev = NULL;
> >
> > @@ -295,13 +295,13 @@ void zzs_stat()
> > unsigned int i,n=0,low=0, hi=0;
> >
> > register Sym **p;
> >
> > float avg=0.0;
> >
> > -
> >
> > +
> >
> > for (i=0; i<20; i++) count[i] = 0;
> >
> > for (p=table; p<&(table[size]); p++)
> >
> > {
> >
> > register Sym *q = *p;
> >
> > unsigned int len;
> >
> > -
> >
> > +
> >
> > if ( q != NULL && low==0 ) low = p-table;
> >
> > len = 0;
> >
> > if ( q != NULL ) printf("[%d]", p-table);
> >
> > @@ -349,14 +349,14 @@ char *text;
> > #endif
> >
> > {
> >
> > Sym *p;
> >
> > -
> >
> > +
> >
> > if ( (p = (Sym *) calloc(1,sizeof(Sym))) == 0 )
> >
> > {
> >
> > fprintf(stderr,"Out of memory\n");
> >
> > exit(1);
> >
> > }
> >
> > p->symbol = zzs_strdup(text);
> >
> > -
> >
> > +
> >
> > return p;
> >
> > }
> >
> >
> >
> > diff --git a/BaseTools/Source/Python/Ecc/Check.py b/BaseTools/Source/Python/Ecc/Check.py
> > index 218081860993..b68cecddfd48 100644
> > --- a/BaseTools/Source/Python/Ecc/Check.py
> > +++ b/BaseTools/Source/Python/Ecc/Check.py
> > @@ -265,7 +265,7 @@ class Check(object):
> > self.FunctionLayoutCheckBody()
> >
> > self.FunctionLayoutCheckLocalVariable()
> >
> > self.FunctionLayoutCheckDeprecated()
> >
> > -
> >
> > +
> >
> > # To check if the deprecated functions are used
> >
> > def FunctionLayoutCheckDeprecated(self):
> >
> > if EccGlobalData.gConfig.CFunctionLayoutCheckNoDeprecated == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1'
> > or EccGlobalData.gConfig.CheckAll == '1':
> >
> > diff --git a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
> > index 4d8b2bdee299..b2f3f6a1127a 100644
> > --- a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
> > +++ b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
> > @@ -160,7 +160,7 @@ class GenFdsGlobalVariable:
> > "OUTPUT_DIR":os.path.join(BuildDir, "OUTPUT"),
> >
> > "DEBUG_DIR":os.path.join(BuildDir, "DEBUG")
> >
> > }
> >
> > -
> >
> > +
> >
> > BuildRules = {}
> >
> > for Type in BuildRuleDatabase.FileTypeList:
> >
> > #first try getting build rule by BuildRuleFamily
> >
> > diff --git a/BaseTools/Source/Python/Makefile b/BaseTools/Source/Python/Makefile
> > index 0361c5330cfe..6c3bedbadf3a 100644
> > --- a/BaseTools/Source/Python/Makefile
> > +++ b/BaseTools/Source/Python/Makefile
> > @@ -8,6 +8,6 @@
> > all:
> >
> >
> >
> > clean:
> >
> > -cleanall:
> >
> > +cleanall:
> >
> > @del /f /q $(BASE_TOOLS_PATH)\Source\Python\*.pyc
> >
> >
> >
> > --
> > 2.20.1
>
next prev parent reply other threads:[~2019-09-20 10:37 UTC|newest]
Thread overview: 23+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-09-19 18:06 [PATCH 0/7] Strip trailing whitespace Leif Lindholm
2019-09-19 18:06 ` [PATCH 1/7] ArmPkg: strip " Leif Lindholm
2019-09-23 9:46 ` [edk2-devel] " Philippe Mathieu-Daudé
2019-09-19 18:06 ` [PATCH 2/7] ArmPlatformPkg: " Leif Lindholm
2019-09-23 9:46 ` [edk2-devel] " Philippe Mathieu-Daudé
2019-09-19 18:06 ` [PATCH 3/7] BaseTools: " Leif Lindholm
2019-09-20 6:06 ` Liming Gao
2019-09-20 10:37 ` Leif Lindholm [this message]
2019-09-23 5:28 ` Liming Gao
2019-09-19 18:06 ` [PATCH 4/7] EmulatorPkg: " Leif Lindholm
2019-09-19 18:28 ` [edk2-devel] " Ni, Ray
2019-09-23 9:46 ` Philippe Mathieu-Daudé
2019-09-19 18:06 ` [PATCH 5/7] MdeModulePkg: " Leif Lindholm
2019-09-20 1:03 ` [edk2-devel] " Wu, Hao A
2019-09-19 18:06 ` [PATCH 6/7] OvmfPkg: " Leif Lindholm
2019-09-20 6:13 ` [edk2-devel] " Laszlo Ersek
2019-09-20 10:24 ` Leif Lindholm
2019-09-23 9:49 ` Philippe Mathieu-Daudé
2019-09-24 16:05 ` Laszlo Ersek
2019-09-19 18:06 ` [PATCH 7/7] UefiCpuPkg: " Leif Lindholm
2019-09-19 18:28 ` [edk2-devel] " Ni, Ray
2019-09-23 9:49 ` Philippe Mathieu-Daudé
2019-09-19 19:20 ` [PATCH 0/7] Strip " Ard Biesheuvel
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20190920103708.GE28454@bivouac.eciton.net \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox