From: "Liming Gao" <liming.gao@intel.com>
To: Leif Lindholm <leif.lindholm@linaro.org>
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: Mon, 23 Sep 2019 05:28:38 +0000 [thread overview]
Message-ID: <4A89E2EF3DFEDB4C8BFDE51014F606A14E4FFD91@SHSMSX104.ccr.corp.intel.com> (raw)
In-Reply-To: <20190920103708.GE28454@bivouac.eciton.net>
Leif:
Thanks. I agree that submodule is the direction for their party code.
I will drive Brotli and Oniguruma to become submodule first.
Thanks
Liming
>-----Original Message-----
>From: Leif Lindholm [mailto:leif.lindholm@linaro.org]
>Sent: Friday, September 20, 2019 6:37 PM
>To: Gao, Liming <liming.gao@intel.com>
>Cc: devel@edk2.groups.io; Feng, Bob C <bob.c.feng@intel.com>
>Subject: Re: [PATCH 3/7] BaseTools: strip trailing whitespace
>
>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_GetPointerToCurrentPo
>s;
>> >
>> > 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_MR
>13.txt
>> >
>b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR
>13.txt
>> > index 33d7d20a6a3c..b95615d8a3c1 100644
>> > ---
>a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR
>13.txt
>> > +++
>b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR
>13.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-23 5:28 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
2019-09-23 5:28 ` Liming Gao [this message]
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=4A89E2EF3DFEDB4C8BFDE51014F606A14E4FFD91@SHSMSX104.ccr.corp.intel.com \
--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