From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: mx.groups.io; dkim=pass header.i=@linaro.org header.s=google header.b=JzO/68kh; spf=pass (domain: linaro.org, ip: 209.85.221.54, mailfrom: leif.lindholm@linaro.org) Received: from mail-wr1-f54.google.com (mail-wr1-f54.google.com [209.85.221.54]) by groups.io with SMTP; Fri, 20 Sep 2019 03:37:15 -0700 Received: by mail-wr1-f54.google.com with SMTP id l11so6230262wrx.5 for ; Fri, 20 Sep 2019 03:37:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=ect5okkhCbxBfMyCup05poHrgm+F4pZnFsJoRbW7bR0=; b=JzO/68khOK9B+yyESjp6X4di1NfGOBqoCywmiZ/pklkOY5wTE/xBaEGNxjw69Sy2Kn jtzhZRQMaP4eXiK6Waa0Md4dR+3jonbb/1NN0UAxfi+m4p7jVqFGoSkYtMe/W/uyNPZX i9mc7KpQsvEp7SbtUgooF/NfhGrmcAbd6eRbmPCt3cGbe79FBWN1DJyUewyli/0l1PpH Msqm0GNfC3uvdlOSOEVgoiQYvPyoIruBmBUGhpK37ZkVI0Qf1jdiSCzqZz8M4FfcNeJq 9I3xsRssLhorP+3ZUnudnPfAVaHivzhKbpbyCNBNvbopgWkokdncuwt/C6SrGZR+nPYl Im/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=ect5okkhCbxBfMyCup05poHrgm+F4pZnFsJoRbW7bR0=; b=cp4F4KPF1h2m1A+Q2nh4bi7O0/gROGxs0gwLvt6bplMl6b+WiUKSgSvK7L7n/tuee8 1gwRr3t94W1SNeNxFk5jt825E4Q9bjqfFyt0AH5ljzxUi+OsB24xPnhBDC0vzzen972Y TUN0AH4T8DF0KzEBRbrPCpt21axvT69zW+D6nO01rukVS8Vu8nRzPP1p5B47qmc8MSRh /hcw+LtyXZNxcQvP0947yZfi0dWsEuNIsBJ0oS8cPe5zEKi7OibNtqYyXPLRV5YEnN2S JH4T7lAJyX0nWKYb28bBVdbsK9iGJ5t0U4CRtAFCErZj/7d7VPDO3uZJg/8T9atvu7fW b/Jg== X-Gm-Message-State: APjAAAWmjuIHGYzOCR2O4ZtnHBTvA3ZqTtRXHm+MUgt9Jji5kFZ8omXe VhLuLqa05ycqk3T3kWZ+ekIhCA== X-Google-Smtp-Source: APXvYqyDB1xkXACAPympGa9fufUsQHDFMs1+wrsXwcYFrYSxq7g2vlQQ2FIl6wZe9OfmQAto3xE3fw== X-Received: by 2002:a5d:680d:: with SMTP id w13mr11354831wru.282.1568975831471; Fri, 20 Sep 2019 03:37:11 -0700 (PDT) Return-Path: Received: from bivouac.eciton.net (bivouac.eciton.net. [2a00:1098:0:86:1000:23:0:2]) by smtp.gmail.com with ESMTPSA id u68sm1991276wmu.12.2019.09.20.03.37.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 20 Sep 2019 03:37:10 -0700 (PDT) Date: Fri, 20 Sep 2019 11:37:08 +0100 From: "Leif Lindholm" To: "Gao, Liming" Cc: "devel@edk2.groups.io" , "Feng, Bob C" Subject: Re: [PATCH 3/7] BaseTools: strip trailing whitespace Message-ID: <20190920103708.GE28454@bivouac.eciton.net> References: <20190919180625.29150-1-leif.lindholm@linaro.org> <20190919180625.29150-4-leif.lindholm@linaro.org> <4A89E2EF3DFEDB4C8BFDE51014F606A14E4FF320@SHSMSX104.ccr.corp.intel.com> MIME-Version: 1.0 In-Reply-To: <4A89E2EF3DFEDB4C8BFDE51014F606A14E4FF320@SHSMSX104.ccr.corp.intel.com> User-Agent: Mutt/1.10.1 (2018-07-13) Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit 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 ; Gao, Liming > > Subject: [PATCH 3/7] BaseTools: strip trailing whitespace > > > > Cc: Bob Feng > > Cc: Liming Gao > > Signed-off-by: Leif Lindholm > > --- > > BaseTools/Source/C/BrotliCompress/tools/brotli.c | 2 +- > > BaseTools/Source/C/GNUmakefile | 2 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c | 20 ++--- > > BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h | 4 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c | 22 ++--- > > BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h | 8 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c | 70 ++++++++-------- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h | 4 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c | 40 +++++----- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h | 4 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c | 30 +++---- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h | 4 +- > > BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c | 194 ++++++++++++++++++++++---------------------- > > BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c | 6 +- > > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt | 92 ++++++++++----------- > > BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt | 102 ++++++++++++------------ > > BaseTools/Source/C/Makefiles/app.makefile | 4 +- > > BaseTools/Source/C/Makefiles/footer.makefile | 4 +- > > BaseTools/Source/C/Makefiles/header.makefile | 8 +- > > BaseTools/Source/C/Makefiles/lib.makefile | 2 +- > > BaseTools/Source/C/Makefiles/ms.common | 4 +- > > BaseTools/Source/C/VfrCompile/GNUmakefile | 6 +- > > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt | 286 > > ++++++++++++++++++++++++++++++++--------------------------------- > > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt | 6 +- > > BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt | 20 ++--- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c | 194 ++++++++++++++++++++++---------------------- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c | 10 +-- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c | 18 ++--- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c | 12 +-- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c | 16 ++-- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c | 16 ++-- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c | 78 +++++++++--------- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c | 10 +-- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c | 6 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c | 40 +++++----- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c | 42 +++++----- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c | 4072 > > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > > ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------ > > ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- > > ------------------------------------------------- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c | 10 +-- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c | 950 > > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------ > > ------------------------------------------------------------------------------------------ > > BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c | 30 +++---- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c | 10 +-- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp | 6 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h | 22 ++--- > > BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp | 2 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp | 8 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h | 10 +-- > > BaseTools/Source/C/VfrCompile/Pccts/h/ast.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/h/err.h | 70 ++++++++-------- > > BaseTools/Source/C/VfrCompile/Pccts/history.txt | 6 +- > > BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c | 14 ++-- > > BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c | 46 +++++------ > > BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c | 46 +++++------ > > BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h | 4 +- > > BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c | 26 +++--- > > BaseTools/Source/Python/Ecc/Check.py | 2 +- > > BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 2 +- > > BaseTools/Source/Python/Makefile | 2 +- > > 75 files changed, 3404 insertions(+), 3404 deletions(-) > > > > diff --git a/BaseTools/Source/C/BrotliCompress/tools/brotli.c b/BaseTools/Source/C/BrotliCompress/tools/brotli.c > > index b0246e1ecf86..946da96013da 100644 > > --- a/BaseTools/Source/C/BrotliCompress/tools/brotli.c > > +++ b/BaseTools/Source/C/BrotliCompress/tools/brotli.c > > @@ -909,7 +909,7 @@ static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) { > > > > > > /* Default brotli_alloc_func */ > > > > void* BrotliAllocFunc(void* opaque, size_t size) { > > > > - *(size_t *)opaque = *(size_t *) opaque + size; > > > > + *(size_t *)opaque = *(size_t *) opaque + size; > > > > return malloc(size); > > > > } > > > > > > > > diff --git a/BaseTools/Source/C/GNUmakefile b/BaseTools/Source/C/GNUmakefile > > index 37bcce519c7e..df4eb64ea95e 100644 > > --- a/BaseTools/Source/C/GNUmakefile > > +++ b/BaseTools/Source/C/GNUmakefile > > @@ -77,7 +77,7 @@ $(SUBDIRS): > > $(patsubst %,%-clean,$(sort $(SUBDIRS))): > > > > -$(MAKE) -C $(@:-clean=) clean > > > > > > > > -$(VFRAUTOGEN): VfrCompile/VfrSyntax.g > > > > +$(VFRAUTOGEN): VfrCompile/VfrSyntax.g > > > > $(MAKE) -C VfrCompile VfrLexer.h > > > > > > > > clean: $(patsubst %,%-clean,$(sort $(SUBDIRS))) > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c > > index e486901e3022..76169000d54d 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c > > @@ -122,12 +122,12 @@ WRes File_Read(CSzFile *p, void *data, size_t *size) > > return 0; > > > > > > > > #else > > > > - > > > > + > > > > *size = fread(data, 1, originalSize, p->file); > > > > if (*size == originalSize) > > > > return 0; > > > > return ferror(p->file); > > > > - > > > > + > > > > #endif > > > > } > > > > > > > > @@ -136,7 +136,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size) > > size_t originalSize = *size; > > > > if (originalSize == 0) > > > > return 0; > > > > - > > > > + > > > > #ifdef USE_WINDOWS_FILE > > > > > > > > *size = 0; > > > > @@ -162,7 +162,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size) > > if (*size == originalSize) > > > > return 0; > > > > return ferror(p->file); > > > > - > > > > + > > > > #endif > > > > } > > > > > > > > @@ -192,7 +192,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin) > > return 0; > > > > > > > > #else > > > > - > > > > + > > > > int moveMethod; > > > > int res; > > > > switch (origin) > > > > @@ -205,14 +205,14 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin) > > res = fseek(p->file, (long)*pos, moveMethod); > > > > *pos = ftell(p->file); > > > > return res; > > > > - > > > > + > > > > #endif > > > > } > > > > > > > > WRes File_GetLength(CSzFile *p, UInt64 *length) > > > > { > > > > #ifdef USE_WINDOWS_FILE > > > > - > > > > + > > > > DWORD sizeHigh; > > > > DWORD sizeLow = GetFileSize(p->handle, &sizeHigh); > > > > if (sizeLow == 0xFFFFFFFF) > > > > @@ -223,15 +223,15 @@ WRes File_GetLength(CSzFile *p, UInt64 *length) > > } > > > > *length = (((UInt64)sizeHigh) << 32) + sizeLow; > > > > return 0; > > > > - > > > > + > > > > #else > > > > - > > > > + > > > > long pos = ftell(p->file); > > > > int res = fseek(p->file, 0, SEEK_END); > > > > *length = ftell(p->file); > > > > fseek(p->file, pos, SEEK_SET); > > > > return res; > > > > - > > > > + > > > > #endif > > > > } > > > > > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > > index 4977cdaa66d9..ab7baee4c4fa 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h > > @@ -241,10 +241,10 @@ typedef struct > > { > > > > ILookInStream vt; > > > > const ISeekInStream *realStream; > > > > - > > > > + > > > > size_t pos; > > > > size_t size; /* it's data size */ > > > > - > > > > + > > > > /* the following variables must be set outside */ > > > > Byte *buf; > > > > size_t bufSize; > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c > > index 30b499e5ff7c..dc8f17977cc1 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c > > @@ -108,13 +108,13 @@ static void PrintAddr(void *p) > > PrintHex(size, 10); \ > > > > PrintAddr(ptr); \ > > > > PrintLn(); > > > > - > > > > + > > > > #define PRINT_FREE(name, cnt, ptr) if (ptr) { \ > > > > Print(name " "); \ > > > > PrintDec(--cnt, 10); \ > > > > PrintAddr(ptr); \ > > > > PrintLn(); } > > > > - > > > > + > > > > #else > > > > > > > > #define PRINT_ALLOC(name, cnt, size, ptr) > > > > @@ -147,7 +147,7 @@ void *MyAlloc(size_t size) > > void MyFree(void *address) > > > > { > > > > PRINT_FREE("Free ", g_allocCount, address); > > > > - > > > > + > > > > free(address); > > > > } > > > > > > > > @@ -157,9 +157,9 @@ void *MidAlloc(size_t size) > > { > > > > if (size == 0) > > > > return NULL; > > > > - > > > > + > > > > PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL); > > > > - > > > > + > > > > return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE); > > > > } > > > > > > > > @@ -203,7 +203,7 @@ void *BigAlloc(size_t size) > > return NULL; > > > > > > > > PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL); > > > > - > > > > + > > > > #ifdef _7ZIP_LARGE_PAGES > > > > { > > > > SIZE_T ps = g_LargePageSize; > > > > @@ -228,7 +228,7 @@ void *BigAlloc(size_t size) > > void BigFree(void *address) > > > > { > > > > PRINT_FREE("Free-Big", g_allocCountBig, address); > > > > - > > > > + > > > > if (!address) > > > > return; > > > > VirtualFree(address, 0, MEM_RELEASE); > > > > @@ -322,7 +322,7 @@ static int posix_memalign(void **ptr, size_t align, size_t size) > > static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size) > > > > { > > > > #ifndef USE_posix_memalign > > > > - > > > > + > > > > void *p; > > > > void *pAligned; > > > > size_t newSize; > > > > @@ -336,7 +336,7 @@ static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size) > > return NULL; > > > > > > > > p = MyAlloc(newSize); > > > > - > > > > + > > > > if (!p) > > > > return NULL; > > > > pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE); > > > > @@ -402,7 +402,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size) > > > > > > if (alignSize < sizeof(void *)) > > > > alignSize = sizeof(void *); > > > > - > > > > + > > > > if (p->offset >= alignSize) > > > > return NULL; > > > > > > > > @@ -414,7 +414,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size) > > return NULL; > > > > > > > > adr = ISzAlloc_Alloc(p->baseAlloc, newSize); > > > > - > > > > + > > > > if (!adr) > > > > return NULL; > > > > > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h > > index aba8dce14f19..ecf7b0c44759 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h > > @@ -11,23 +11,23 @@ EXTERN_C_BEGIN > > /* > > > > These functions convert relative addresses to absolute addresses > > > > in CALL instructions to increase the compression ratio. > > > > - > > > > + > > > > In: > > > > data - data buffer > > > > size - size of data > > > > ip - current virtual Instruction Pinter (IP) value > > > > state - state variable for x86 converter > > > > encoding - 0 (for decoding), 1 (for encoding) > > > > - > > > > + > > > > Out: > > > > state - state variable for x86 converter > > > > > > > > Returns: > > > > The number of processed bytes. If you call these functions with multiple calls, > > > > you must start next call with first byte after block of processed bytes. > > > > - > > > > + > > > > Type Endian Alignment LookAhead > > > > - > > > > + > > > > x86 little 1 4 > > > > ARMT little 2 2 > > > > ARM little 4 0 > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > > index 6ea82a9b5344..507eb026f168 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c > > @@ -73,7 +73,7 @@ static void MatchFinder_ReadBlock(CMatchFinder *p) > > p->streamEndWasReached = 1; > > > > return; > > > > } > > > > - > > > > + > > > > for (;;) > > > > { > > > > Byte *dest = p->buffer + (p->streamPos - p->pos); > > > > @@ -180,24 +180,24 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize, > > ISzAllocPtr alloc) > > > > { > > > > UInt32 sizeReserv; > > > > - > > > > + > > > > if (historySize > kMaxHistorySize) > > > > { > > > > MatchFinder_Free(p, alloc); > > > > return 0; > > > > } > > > > - > > > > + > > > > sizeReserv = historySize >> 1; > > > > if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3; > > > > else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2; > > > > - > > > > + > > > > sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19); > > > > > > > > p->keepSizeBefore = historySize + keepAddBufferBefore + 1; > > > > p->keepSizeAfter = matchMaxLen + keepAddBufferAfter; > > > > - > > > > + > > > > /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */ > > > > - > > > > + > > > > if (LzInWindow_Create(p, sizeReserv, alloc)) > > > > { > > > > UInt32 newCyclicBufferSize = historySize + 1; > > > > @@ -243,7 +243,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize, > > p->historySize = historySize; > > > > p->hashSizeSum = hs; > > > > p->cyclicBufferSize = newCyclicBufferSize; > > > > - > > > > + > > > > numSons = newCyclicBufferSize; > > > > if (p->btMode) > > > > numSons <<= 1; > > > > @@ -251,11 +251,11 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize, > > > > > > if (p->hash && p->numRefs == newSize) > > > > return 1; > > > > - > > > > + > > > > MatchFinder_FreeThisClassMemory(p, alloc); > > > > p->numRefs = newSize; > > > > p->hash = AllocRefs(newSize, alloc); > > > > - > > > > + > > > > if (p->hash) > > > > { > > > > p->son = p->hash + p->hashSizeSum; > > > > @@ -272,11 +272,11 @@ static void MatchFinder_SetLimits(CMatchFinder *p) > > { > > > > UInt32 limit = kMaxValForNormalize - p->pos; > > > > UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos; > > > > - > > > > + > > > > if (limit2 < limit) > > > > limit = limit2; > > > > limit2 = p->streamPos - p->pos; > > > > - > > > > + > > > > if (limit2 <= p->keepSizeAfter) > > > > { > > > > if (limit2 > 0) > > > > @@ -284,10 +284,10 @@ static void MatchFinder_SetLimits(CMatchFinder *p) > > } > > > > else > > > > limit2 -= p->keepSizeAfter; > > > > - > > > > + > > > > if (limit2 < limit) > > > > limit = limit2; > > > > - > > > > + > > > > { > > > > UInt32 lenLimit = p->streamPos - p->pos; > > > > if (lenLimit > p->matchMaxLen) > > > > @@ -326,10 +326,10 @@ void MatchFinder_Init_3(CMatchFinder *p, int readData) > > p->streamPos = p->cyclicBufferSize; > > > > p->result = SZ_OK; > > > > p->streamEndWasReached = 0; > > > > - > > > > + > > > > if (readData) > > > > MatchFinder_ReadBlock(p); > > > > - > > > > + > > > > MatchFinder_SetLimits(p); > > > > } > > > > > > > > @@ -341,7 +341,7 @@ void MatchFinder_Init(CMatchFinder *p) > > MatchFinder_Init_3(p, True); > > > > } > > > > > > > > - > > > > + > > > > static UInt32 MatchFinder_GetSubValue(CMatchFinder *p) > > > > { > > > > return (p->pos - p->historySize - 1) & kNormalizeMask; > > > > @@ -584,7 +584,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > d2 = pos - hash[h2]; > > > > > > > > curMatch = (hash + kFix3HashSize)[hv]; > > > > - > > > > + > > > > hash[h2] = pos; > > > > (hash + kFix3HashSize)[hv] = pos; > > > > > > > > @@ -603,7 +603,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > MOVE_POS_RET; > > > > } > > > > } > > > > - > > > > + > > > > GET_MATCHES_FOOTER(offset, maxLen) > > > > } > > > > > > > > @@ -629,14 +629,14 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > > > > maxLen = 0; > > > > offset = 0; > > > > - > > > > + > > > > if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur) > > > > { > > > > distances[0] = maxLen = 2; > > > > distances[1] = d2 - 1; > > > > offset = 2; > > > > } > > > > - > > > > + > > > > if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur) > > > > { > > > > maxLen = 3; > > > > @@ -644,7 +644,7 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset += 2; > > > > d2 = d3; > > > > } > > > > - > > > > + > > > > if (offset != 0) > > > > { > > > > UPDATE_maxLen > > > > @@ -655,10 +655,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > MOVE_POS_RET; > > > > } > > > > } > > > > - > > > > + > > > > if (maxLen < 3) > > > > maxLen = 3; > > > > - > > > > + > > > > GET_MATCHES_FOOTER(offset, maxLen) > > > > } > > > > > > > > @@ -710,7 +710,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset = 2; > > > > d2 = d3; > > > > } > > > > - > > > > + > > > > if (d2 != d4 && d4 < p->cyclicBufferSize > > > > && *(cur - d4) == *cur > > > > && *(cur - d4 + 3) == *(cur + 3)) > > > > @@ -720,7 +720,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset += 2; > > > > d2 = d4; > > > > } > > > > - > > > > + > > > > if (offset != 0) > > > > { > > > > UPDATE_maxLen > > > > @@ -734,7 +734,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > > > > if (maxLen < 4) > > > > maxLen = 4; > > > > - > > > > + > > > > GET_MATCHES_FOOTER(offset, maxLen) > > > > } > > > > */ > > > > @@ -749,10 +749,10 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > > > > hash = p->hash; > > > > pos = p->pos; > > > > - > > > > + > > > > d2 = pos - hash[ h2]; > > > > d3 = pos - (hash + kFix3HashSize)[h3]; > > > > - > > > > + > > > > curMatch = (hash + kFix4HashSize)[hv]; > > > > > > > > hash[ h2] = pos; > > > > @@ -768,7 +768,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > distances[1] = d2 - 1; > > > > offset = 2; > > > > } > > > > - > > > > + > > > > if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur) > > > > { > > > > maxLen = 3; > > > > @@ -776,7 +776,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset += 2; > > > > d2 = d3; > > > > } > > > > - > > > > + > > > > if (offset != 0) > > > > { > > > > UPDATE_maxLen > > > > @@ -787,7 +787,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > MOVE_POS_RET; > > > > } > > > > } > > > > - > > > > + > > > > if (maxLen < 3) > > > > maxLen = 3; > > > > > > > > @@ -807,7 +807,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > > > > > hash = p->hash; > > > > pos = p->pos; > > > > - > > > > + > > > > d2 = pos - hash[ h2]; > > > > d3 = pos - (hash + kFix3HashSize)[h3]; > > > > d4 = pos - (hash + kFix4HashSize)[h4]; > > > > @@ -844,7 +844,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset = 2; > > > > d2 = d3; > > > > } > > > > - > > > > + > > > > if (d2 != d4 && d4 < p->cyclicBufferSize > > > > && *(cur - d4) == *cur > > > > && *(cur - d4 + 3) == *(cur + 3)) > > > > @@ -854,7 +854,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > offset += 2; > > > > d2 = d4; > > > > } > > > > - > > > > + > > > > if (offset != 0) > > > > { > > > > UPDATE_maxLen > > > > @@ -865,7 +865,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances) > > MOVE_POS_RET; > > > > } > > > > } > > > > - > > > > + > > > > if (maxLen < 4) > > > > maxLen = 4; > > > > > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h > > index c77added7bd3..61bb9dd302b5 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h > > @@ -34,7 +34,7 @@ typedef struct _CMatchFinder > > > > > > Byte *bufferBase; > > > > ISeqInStream *stream; > > > > - > > > > + > > > > UInt32 blockSize; > > > > UInt32 keepSizeBefore; > > > > UInt32 keepSizeAfter; > > > > @@ -59,7 +59,7 @@ typedef struct _CMatchFinder > > ((p)->streamEndWasReached \ > > > > && (p)->streamPos == (p)->pos \ > > > > && (!(p)->directInput || (p)->directInputRem == 0)) > > > > - > > > > + > > > > int MatchFinder_NeedMove(CMatchFinder *p); > > > > Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p); > > > > void MatchFinder_MoveBlock(CMatchFinder *p); > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > > index 2563824fcdef..8e7cf6493ce3 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c > > @@ -62,7 +62,7 @@ static void MtSync_StopWriting(CMtSync *p) > > p->csWasEntered = False; > > > > } > > > > Semaphore_Release1(&p->freeSemaphore); > > > > - > > > > + > > > > Event_Wait(&p->wasStopped); > > > > > > > > while (myNumBlocks++ != p->numProcessedBlocks) > > > > @@ -112,12 +112,12 @@ static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj, > > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart)); > > > > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStarted)); > > > > RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped)); > > > > - > > > > + > > > > RINOK_THREAD(Semaphore_Create(&p->freeSemaphore, numBlocks, numBlocks)); > > > > RINOK_THREAD(Semaphore_Create(&p->filledSemaphore, 0, numBlocks)); > > > > > > > > p->needStart = True; > > > > - > > > > + > > > > RINOK_THREAD(Thread_Create(&p->thread, startAddress, obj)); > > > > p->wasCreated = True; > > > > return SZ_OK; > > > > @@ -320,9 +320,9 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances) > > UInt32 numProcessed = 0; > > > > UInt32 curPos = 2; > > > > UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2); > > > > - > > > > + > > > > distances[1] = p->hashNumAvail; > > > > - > > > > + > > > > while (curPos < limit) > > > > { > > > > if (p->hashBufPos == p->hashBufPosLimit) > > > > @@ -352,7 +352,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances) > > if (size2 < size) > > > > size = size2; > > > > } > > > > - > > > > + > > > > #ifndef MFMT_GM_INLINE > > > > while (curPos < limit && size-- != 0) > > > > { > > > > @@ -386,7 +386,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances) > > p->cyclicBufferPos = cyclicBufferPos; > > > > } > > > > } > > > > - > > > > + > > > > distances[0] = curPos; > > > > } > > > > > > > > @@ -398,7 +398,7 @@ static void BtFillBlock(CMatchFinderMt *p, UInt32 globalBlockIndex) > > CriticalSection_Enter(&sync->cs); > > > > sync->csWasEntered = True; > > > > } > > > > - > > > > + > > > > BtGetMatches(p, p->btBuf + (globalBlockIndex & kMtBtNumBlocksMask) * kMtBtBlockSize); > > > > > > > > if (p->pos > kMtMaxValForNormalize - kMtBtBlockSize) > > > > @@ -504,7 +504,7 @@ SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddB > > static void MatchFinderMt_Init(CMatchFinderMt *p) > > > > { > > > > CMatchFinder *mf = p->MatchFinder; > > > > - > > > > + > > > > p->btBufPos = > > > > p->btBufPosLimit = 0; > > > > p->hashBufPos = > > > > @@ -513,7 +513,7 @@ static void MatchFinderMt_Init(CMatchFinderMt *p) > > /* Init without data reading. We don't want to read data in this thread */ > > > > MatchFinder_Init_3(mf, False); > > > > MatchFinder_Init_LowHash(mf); > > > > - > > > > + > > > > p->pointerToCurPos = Inline_MatchFinder_GetPointerToCurrentPos(mf); > > > > p->btNumAvailBytes = 0; > > > > p->lzPos = p->historySize + 1; > > > > @@ -577,7 +577,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista > > const Byte *cur = p->pointerToCurPos; > > > > UInt32 lzPos = p->lzPos; > > > > MT_HASH2_CALC > > > > - > > > > + > > > > curMatch2 = hash[h2]; > > > > hash[h2] = lzPos; > > > > > > > > @@ -587,7 +587,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista > > *distances++ = 2; > > > > *distances++ = lzPos - curMatch2 - 1; > > > > } > > > > - > > > > + > > > > return distances; > > > > } > > > > > > > > @@ -601,7 +601,7 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista > > > > > > curMatch2 = hash[ h2]; > > > > curMatch3 = (hash + kFix3HashSize)[h3]; > > > > - > > > > + > > > > hash[ h2] = lzPos; > > > > (hash + kFix3HashSize)[h3] = lzPos; > > > > > > > > @@ -616,13 +616,13 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista > > distances[0] = 2; > > > > distances += 2; > > > > } > > > > - > > > > + > > > > if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0]) > > > > { > > > > *distances++ = 3; > > > > *distances++ = lzPos - curMatch3 - 1; > > > > } > > > > - > > > > + > > > > return distances; > > > > } > > > > > > > > @@ -634,11 +634,11 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan > > const Byte *cur = p->pointerToCurPos; > > > > UInt32 lzPos = p->lzPos; > > > > MT_HASH4_CALC > > > > - > > > > + > > > > curMatch2 = hash[ h2]; > > > > curMatch3 = (hash + kFix3HashSize)[h3]; > > > > curMatch4 = (hash + kFix4HashSize)[h4]; > > > > - > > > > + > > > > hash[ h2] = lzPos; > > > > (hash + kFix3HashSize)[h3] = lzPos; > > > > (hash + kFix4HashSize)[h4] = lzPos; > > > > @@ -654,7 +654,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan > > distances[0] = 2; > > > > distances += 2; > > > > } > > > > - > > > > + > > > > if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0]) > > > > { > > > > distances[1] = lzPos - curMatch3 - 1; > > > > @@ -676,7 +676,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan > > *distances++ = 4; > > > > *distances++ = lzPos - curMatch4 - 1; > > > > } > > > > - > > > > + > > > > return distances; > > > > } > > > > */ > > > > @@ -789,7 +789,7 @@ void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable) > > vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinderMt_GetNumAvailableBytes; > > > > vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinderMt_GetPointerToCurrentPos; > > > > vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches; > > > > - > > > > + > > > > switch (p->MatchFinder->numHashBytes) > > > > { > > > > case 2: > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > > index 3d86c788f3f9..b1398a883aaf 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h > > @@ -60,7 +60,7 @@ typedef struct _CMatchFinderMt > > const UInt32 *crc; > > > > > > > > Mf_Mix_Matches MixMatchesFunc; > > > > - > > > > + > > > > /* LZ + BT */ > > > > CMtSync btSync; > > > > Byte btDummy[kMtCacheLineDummy]; > > > > @@ -83,7 +83,7 @@ typedef struct _CMatchFinderMt > > /* BT + Hash */ > > > > CMtSync hashSync; > > > > /* Byte hashDummy[kMtCacheLineDummy]; */ > > > > - > > > > + > > > > /* Hash */ > > > > Mf_GetHeads GetHeadsFunc; > > > > CMatchFinder *MatchFinder; > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > > index 962b94bb6338..6328c9011aa0 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c > > @@ -227,7 +227,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > Byte *dic = p->dic; > > > > SizeT dicBufSize = p->dicBufSize; > > > > SizeT dicPos = p->dicPos; > > > > - > > > > + > > > > UInt32 processedPos = p->processedPos; > > > > UInt32 checkDicSize = p->checkDicSize; > > > > unsigned len = 0; > > > > @@ -303,7 +303,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > dic[dicPos++] = (Byte)symbol; > > > > continue; > > > > } > > > > - > > > > + > > > > { > > > > UPDATE_1(prob); > > > > prob = probs + IsRep + state; > > > > @@ -370,7 +370,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > state = state < kNumLitStates ? 8 : 11; > > > > prob = probs + RepLenCoder; > > > > } > > > > - > > > > + > > > > #ifdef _LZMA_SIZE_OPT > > > > { > > > > unsigned lim, offset; > > > > @@ -474,7 +474,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > { > > > > NORMALIZE > > > > range >>= 1; > > > > - > > > > + > > > > { > > > > UInt32 t; > > > > code -= range; > > > > @@ -510,7 +510,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > } > > > > } > > > > } > > > > - > > > > + > > > > rep3 = rep2; > > > > rep2 = rep1; > > > > rep1 = rep0; > > > > @@ -529,13 +529,13 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > SizeT rem; > > > > unsigned curLen; > > > > SizeT pos; > > > > - > > > > + > > > > if ((rem = limit - dicPos) == 0) > > > > { > > > > p->dicPos = dicPos; > > > > return SZ_ERROR_DATA; > > > > } > > > > - > > > > + > > > > curLen = ((rem < len) ? (unsigned)rem : len); > > > > pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0); > > > > > > > > @@ -568,7 +568,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit > > while (dicPos < limit && buf < bufLimit); > > > > > > > > NORMALIZE; > > > > - > > > > + > > > > p->buf = buf; > > > > p->range = range; > > > > p->code = code; > > > > @@ -638,10 +638,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte > > } > > > > > > > > RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit)); > > > > - > > > > + > > > > if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize) > > > > p->checkDicSize = p->prop.dicSize; > > > > - > > > > + > > > > LzmaDec_WriteRem(p, limit); > > > > } > > > > while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart); > > > > @@ -877,7 +877,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr > > { > > > > SizeT inSize = *srcLen; > > > > (*srcLen) = 0; > > > > - > > > > + > > > > *status = LZMA_STATUS_NOT_SPECIFIED; > > > > > > > > if (p->remainLen > kMatchSpecLenStart) > > > > @@ -995,7 +995,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr > > p->buf = p->tempBuf; > > > > if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0) > > > > return SZ_ERROR_DATA; > > > > - > > > > + > > > > { > > > > unsigned kkk = (unsigned)(p->buf - p->tempBuf); > > > > if (rem < kkk) > > > > @@ -1011,7 +1011,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr > > p->tempBufSize = 0; > > > > } > > > > } > > > > - > > > > + > > > > if (p->code != 0) > > > > return SZ_ERROR_DATA; > > > > *status = LZMA_STATUS_FINISHED_WITH_MARK; > > > > @@ -1081,12 +1081,12 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size) > > { > > > > UInt32 dicSize; > > > > Byte d; > > > > - > > > > + > > > > if (size < LZMA_PROPS_SIZE) > > > > return SZ_ERROR_UNSUPPORTED; > > > > else > > > > dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24); > > > > - > > > > + > > > > if (dicSize < LZMA_DIC_MIN) > > > > dicSize = LZMA_DIC_MIN; > > > > p->dicSize = dicSize; > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h > > index 28ce60c3ea94..ebc568cb4ff4 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h > > @@ -135,7 +135,7 @@ LzmaDec_Allocate* can return: > > SZ_ERROR_MEM - Memory allocation error > > > > SZ_ERROR_UNSUPPORTED - Unsupported properties > > > > */ > > > > - > > > > + > > > > SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc); > > > > void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc); > > > > > > > > @@ -164,7 +164,7 @@ void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc); > > */ > > > > > > > > /* LzmaDec_DecodeToDic > > > > - > > > > + > > > > The decoding to internal dictionary buffer (CLzmaDec::dic). > > > > You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!! > > > > > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > > index e281716fee1b..d7931cd73799 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c > > @@ -52,7 +52,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p) > > int level = p->level; > > > > if (level < 0) level = 5; > > > > p->level = level; > > > > - > > > > + > > > > if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26))); > > > > if (p->dictSize > p->reduceSize) > > > > { > > > > @@ -74,7 +74,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p) > > if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1); > > > > if (p->numHashBytes < 0) p->numHashBytes = 4; > > > > if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1); > > > > - > > > > + > > > > if (p->numThreads < 0) > > > > p->numThreads = > > > > #ifndef _7ZIP_ST > > > > @@ -124,7 +124,7 @@ static void LzmaEnc_FastPosInit(Byte *g_FastPos) > > g_FastPos[0] = 0; > > > > g_FastPos[1] = 1; > > > > g_FastPos += 2; > > > > - > > > > + > > > > for (slot = 2; slot < kNumLogBits * 2; slot++) > > > > { > > > > size_t k = ((size_t)1 << ((slot >> 1) - 1)); > > > > @@ -273,7 +273,7 @@ typedef struct > > > > > > CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits]; > > > > CLzmaProb posEncoders[kNumFullDistances]; > > > > - > > > > + > > > > CLenEnc lenProbs; > > > > CLenEnc repLenProbs; > > > > > > > > @@ -315,7 +315,7 @@ typedef struct > > Bool needInit; > > > > > > > > UInt64 nowPos64; > > > > - > > > > + > > > > unsigned matchPriceCount; > > > > unsigned alignPriceCount; > > > > > > > > @@ -336,7 +336,7 @@ typedef struct > > #ifndef _7ZIP_ST > > > > Byte pad[128]; > > > > #endif > > > > - > > > > + > > > > // LZ thread > > > > CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits]; > > > > > > > > @@ -355,7 +355,7 @@ typedef struct > > CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX]; > > > > CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits]; > > > > CLzmaProb posEncoders[kNumFullDistances]; > > > > - > > > > + > > > > CLenEnc lenProbs; > > > > CLenEnc repLenProbs; > > > > > > > > @@ -383,9 +383,9 @@ void LzmaEnc_SaveState(CLzmaEncHandle pp) > > { > > > > CLzmaEnc *p = (CLzmaEnc *)pp; > > > > CSaveState *dest = &p->saveState; > > > > - > > > > + > > > > dest->state = p->state; > > > > - > > > > + > > > > dest->lenProbs = p->lenProbs; > > > > dest->repLenProbs = p->repLenProbs; > > > > > > > > @@ -414,9 +414,9 @@ void LzmaEnc_RestoreState(CLzmaEncHandle pp) > > > > > > dest->lenProbs = p->lenProbs; > > > > dest->repLenProbs = p->repLenProbs; > > > > - > > > > + > > > > COPY_ARR(dest, p, reps); > > > > - > > > > + > > > > COPY_ARR(dest, p, posAlignEncoder); > > > > COPY_ARR(dest, p, isRep); > > > > COPY_ARR(dest, p, isRepG0); > > > > @@ -914,7 +914,7 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates, > > printf("\n MovePos %u", num); > > > > #endif > > > > */ > > > > - > > > > + > > > > #define MOVE_POS(p, num) { \ > > > > p->additionalOffset += (num); \ > > > > p->matchFinder.Skip(p->matchFinderObj, (num)); } > > > > @@ -923,12 +923,12 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates, > > static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes) > > > > { > > > > unsigned numPairs; > > > > - > > > > + > > > > p->additionalOffset++; > > > > p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj); > > > > numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches); > > > > *numPairsRes = numPairs; > > > > - > > > > + > > > > #ifdef SHOW_STAT > > > > printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2); > > > > g_STAT_OFFSET++; > > > > @@ -938,7 +938,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes) > > printf("%2u %6u | ", p->matches[i], p->matches[i + 1]); > > > > } > > > > #endif > > > > - > > > > + > > > > if (numPairs == 0) > > > > return 0; > > > > { > > > > @@ -976,7 +976,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes) > > + GET_PRICE_1(p->isRep0Long[state][posState])) \ > > > > + GET_PRICE_1(p->isRep[state]) \ > > > > + GET_PRICE_0(p->isRepG0[state]) > > > > - > > > > + > > > > > > > > static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState) > > > > { > > > > @@ -1042,7 +1042,7 @@ static unsigned Backward(CLzmaEnc *p, unsigned cur) > > p->optCur = wr; > > > > return len; > > > > } > > > > - > > > > + > > > > wr--; > > > > p->opt[wr].dist = dist; > > > > p->opt[wr].len = len; > > > > @@ -1068,9 +1068,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > UInt32 matchPrice, repMatchPrice; > > > > const Byte *data; > > > > Byte curByte, matchByte; > > > > - > > > > + > > > > p->optCur = p->optEnd = 0; > > > > - > > > > + > > > > if (p->additionalOffset == 0) > > > > mainLen = ReadMatchDistances(p, &numPairs); > > > > else > > > > @@ -1078,7 +1078,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > mainLen = p->longestMatchLen; > > > > numPairs = p->numPairs; > > > > } > > > > - > > > > + > > > > numAvail = p->numAvail; > > > > if (numAvail < 2) > > > > { > > > > @@ -1087,10 +1087,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > if (numAvail > LZMA_MATCH_LEN_MAX) > > > > numAvail = LZMA_MATCH_LEN_MAX; > > > > - > > > > + > > > > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1; > > > > repMaxIndex = 0; > > > > - > > > > + > > > > for (i = 0; i < LZMA_NUM_REPS; i++) > > > > { > > > > unsigned len; > > > > @@ -1107,7 +1107,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > if (len > repLens[repMaxIndex]) > > > > repMaxIndex = i; > > > > } > > > > - > > > > + > > > > if (repLens[repMaxIndex] >= p->numFastBytes) > > > > { > > > > unsigned len; > > > > @@ -1116,29 +1116,29 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > MOVE_POS(p, len - 1) > > > > return len; > > > > } > > > > - > > > > + > > > > matches = p->matches; > > > > - > > > > + > > > > if (mainLen >= p->numFastBytes) > > > > { > > > > p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS; > > > > MOVE_POS(p, mainLen - 1) > > > > return mainLen; > > > > } > > > > - > > > > + > > > > curByte = *data; > > > > matchByte = *(data - reps[0]); > > > > - > > > > + > > > > if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < 2) > > > > { > > > > p->backRes = MARK_LIT; > > > > return 1; > > > > } > > > > - > > > > + > > > > p->opt[0].state = (CState)p->state; > > > > - > > > > + > > > > posState = (position & p->pbMask); > > > > - > > > > + > > > > { > > > > const CLzmaProb *probs = LIT_PROBS(position, *(data - 1)); > > > > p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) + > > > > @@ -1146,12 +1146,12 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) : > > > > LitEnc_GetPrice(probs, curByte, p->ProbPrices)); > > > > } > > > > - > > > > + > > > > MakeAs_Lit(&p->opt[1]); > > > > - > > > > + > > > > matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]); > > > > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]); > > > > - > > > > + > > > > if (matchByte == curByte) > > > > { > > > > UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState); > > > > @@ -1161,22 +1161,22 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > MakeAs_ShortRep(&p->opt[1]); > > > > } > > > > } > > > > - > > > > + > > > > last = (mainLen >= repLens[repMaxIndex] ? mainLen : repLens[repMaxIndex]); > > > > - > > > > + > > > > if (last < 2) > > > > { > > > > p->backRes = p->opt[1].dist; > > > > return 1; > > > > } > > > > - > > > > + > > > > p->opt[1].len = 1; > > > > - > > > > + > > > > p->opt[0].reps[0] = reps[0]; > > > > p->opt[0].reps[1] = reps[1]; > > > > p->opt[0].reps[2] = reps[2]; > > > > p->opt[0].reps[3] = reps[3]; > > > > - > > > > + > > > > { > > > > unsigned len = last; > > > > do > > > > @@ -1185,7 +1185,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > > > > > // ---------- REP ---------- > > > > - > > > > + > > > > for (i = 0; i < LZMA_NUM_REPS; i++) > > > > { > > > > unsigned repLen = repLens[i]; > > > > @@ -1207,8 +1207,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > while (--repLen >= 2); > > > > } > > > > - > > > > - > > > > + > > > > + > > > > // ---------- MATCH ---------- > > > > { > > > > unsigned len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2); > > > > @@ -1219,14 +1219,14 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > > > > > while (len > matches[offs]) > > > > offs += 2; > > > > - > > > > + > > > > for (; ; len++) > > > > { > > > > COptimal *opt; > > > > UInt32 dist = matches[(size_t)offs + 1]; > > > > UInt32 price2 = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN]; > > > > unsigned lenToPosState = GetLenToPosState(len); > > > > - > > > > + > > > > if (dist < kNumFullDistances) > > > > price2 += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)]; > > > > else > > > > @@ -1236,9 +1236,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > price2 += p->alignPrices[dist & kAlignMask]; > > > > price2 += p->posSlotPrices[lenToPosState][slot]; > > > > } > > > > - > > > > + > > > > opt = &p->opt[len]; > > > > - > > > > + > > > > if (price2 < opt->price) > > > > { > > > > opt->price = price2; > > > > @@ -1246,7 +1246,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > opt->dist = dist + LZMA_NUM_REPS; > > > > opt->extra = 0; > > > > } > > > > - > > > > + > > > > if (len == matches[offs]) > > > > { > > > > offs += 2; > > > > @@ -1256,7 +1256,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > } > > > > } > > > > - > > > > + > > > > > > > > cur = 0; > > > > > > > > @@ -1272,7 +1272,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > > > > > > > > > - > > > > + > > > > // ---------- Optimal Parsing ---------- > > > > > > > > for (;;) > > > > @@ -1289,17 +1289,17 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > return Backward(p, cur); > > > > > > > > newLen = ReadMatchDistances(p, &numPairs); > > > > - > > > > + > > > > if (newLen >= p->numFastBytes) > > > > { > > > > p->numPairs = numPairs; > > > > p->longestMatchLen = newLen; > > > > return Backward(p, cur); > > > > } > > > > - > > > > + > > > > curOpt = &p->opt[cur]; > > > > prev = cur - curOpt->len; > > > > - > > > > + > > > > if (curOpt->len == 1) > > > > { > > > > state = p->opt[prev].state; > > > > @@ -1368,7 +1368,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > reps[3] = prevOpt->reps[2]; > > > > } > > > > } > > > > - > > > > + > > > > curOpt->state = (CState)state; > > > > curOpt->reps[0] = reps[0]; > > > > curOpt->reps[1] = reps[1]; > > > > @@ -1403,7 +1403,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > litPrice += (!IsLitState(state) ? > > > > LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) : > > > > LitEnc_GetPrice(probs, curByte, p->ProbPrices)); > > > > - > > > > + > > > > if (litPrice < nextOpt->price) > > > > { > > > > nextOpt->price = litPrice; > > > > @@ -1415,7 +1415,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > > > > > matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]); > > > > repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]); > > > > - > > > > + > > > > // ---------- SHORT_REP ---------- > > > > // if (IsLitState(state)) // 18.new > > > > if (matchByte == curByte) > > > > @@ -1435,7 +1435,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > nextIsLit = False; > > > > } > > > > } > > > > - > > > > + > > > > numAvailFull = p->numAvail; > > > > { > > > > UInt32 temp = kNumOpts - 1 - cur; > > > > @@ -1467,7 +1467,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > for (len = 3; len < limit && data[len] == data2[len]; len++) > > > > { > > > > } > > > > - > > > > + > > > > { > > > > unsigned state2 = kLiteralNextStates[state]; > > > > unsigned posState2 = (position + 1) & p->pbMask; > > > > @@ -1476,7 +1476,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > unsigned offset = cur + len; > > > > while (last < offset) > > > > p->opt[++last].price = kInfinityPrice; > > > > - > > > > + > > > > // do > > > > { > > > > UInt32 price2; > > > > @@ -1500,7 +1500,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > } > > > > } > > > > - > > > > + > > > > startLen = 2; /* speed optimization */ > > > > { > > > > // ---------- REP ---------- > > > > @@ -1513,9 +1513,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > const Byte *data2 = data - reps[repIndex]; > > > > if (data[0] != data2[0] || data[1] != data2[1]) > > > > continue; > > > > - > > > > + > > > > for (len = 2; len < numAvail && data[len] == data2[len]; len++); > > > > - > > > > + > > > > // if (len < startLen) continue; // 18.new: speed optimization > > > > > > > > while (last < cur + len) > > > > @@ -1537,7 +1537,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > while (--len2 >= 2); > > > > } > > > > - > > > > + > > > > if (repIndex == 0) startLen = len + 1; // 17.old > > > > // startLen = len + 1; // 18.new > > > > > > > > @@ -1550,9 +1550,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > unsigned limit = len2 + p->numFastBytes; > > > > if (limit > numAvailFull) > > > > limit = numAvailFull; > > > > - > > > > + > > > > for (; len2 < limit && data[len2] == data2[len2]; len2++); > > > > - > > > > + > > > > len2 -= len; > > > > if (len2 >= 3) > > > > { > > > > @@ -1563,7 +1563,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > + GET_PRICE_0(p->isMatch[state2][posState2]) > > > > + LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]), > > > > data[len], data2[len], p->ProbPrices); > > > > - > > > > + > > > > // state2 = kLiteralNextStates[state2]; > > > > state2 = kState_LitAfterRep; > > > > posState2 = (posState2 + 1) & p->pbMask; > > > > @@ -1609,7 +1609,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > matches[numPairs] = newLen; > > > > numPairs += 2; > > > > } > > > > - > > > > + > > > > if (newLen >= startLen) > > > > { > > > > UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]); > > > > @@ -1622,10 +1622,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > while (startLen > matches[offs]) > > > > offs += 2; > > > > dist = matches[(size_t)offs + 1]; > > > > - > > > > + > > > > // if (dist >= kNumFullDistances) > > > > GetPosSlot2(dist, posSlot); > > > > - > > > > + > > > > for (len = /*2*/ startLen; ; len++) > > > > { > > > > UInt32 price = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN]; > > > > @@ -1636,7 +1636,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)]; > > > > else > > > > price += p->posSlotPrices[lenToPosState][posSlot] + p->alignPrices[dist & kAlignMask]; > > > > - > > > > + > > > > opt = &p->opt[cur + len]; > > > > if (price < opt->price) > > > > { > > > > @@ -1656,11 +1656,11 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > unsigned limit = len2 + p->numFastBytes; > > > > if (limit > numAvailFull) > > > > limit = numAvailFull; > > > > - > > > > + > > > > for (; len2 < limit && data[len2] == data2[len2]; len2++); > > > > - > > > > + > > > > len2 -= len; > > > > - > > > > + > > > > if (len2 >= 3) > > > > { > > > > unsigned state2 = kMatchNextStates[state]; > > > > @@ -1698,7 +1698,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position) > > } > > > > // while (len2 >= 3); > > > > } > > > > - > > > > + > > > > offs += 2; > > > > if (offs == numPairs) > > > > break; > > > > @@ -1739,7 +1739,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > > numAvail = LZMA_MATCH_LEN_MAX; > > > > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1; > > > > repLen = repIndex = 0; > > > > - > > > > + > > > > for (i = 0; i < LZMA_NUM_REPS; i++) > > > > { > > > > unsigned len; > > > > @@ -1768,7 +1768,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > > } > > > > > > > > mainDist = 0; /* for GCC */ > > > > - > > > > + > > > > if (mainLen >= 2) > > > > { > > > > mainDist = p->matches[(size_t)numPairs - 1]; > > > > @@ -1797,14 +1797,14 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > > MOVE_POS(p, repLen - 1) > > > > return repLen; > > > > } > > > > - > > > > + > > > > if (mainLen < 2 || numAvail <= 2) > > > > return 1; > > > > > > > > { > > > > unsigned len1 = ReadMatchDistances(p, &p->numPairs); > > > > p->longestMatchLen = len1; > > > > - > > > > + > > > > if (len1 >= 2) > > > > { > > > > UInt32 newDist = p->matches[(size_t)p->numPairs - 1]; > > > > @@ -1815,9 +1815,9 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > > return 1; > > > > } > > > > } > > > > - > > > > + > > > > data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1; > > > > - > > > > + > > > > for (i = 0; i < LZMA_NUM_REPS; i++) > > > > { > > > > unsigned len, limit; > > > > @@ -1833,7 +1833,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p) > > break; > > > > } > > > > } > > > > - > > > > + > > > > p->backRes = mainDist + LZMA_NUM_REPS; > > > > if (mainLen != 2) > > > > { > > > > @@ -1859,7 +1859,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState) > > RC_BIT_0(&p->rc, prob) > > > > } > > > > p->state = kMatchNextStates[p->state]; > > > > - > > > > + > > > > p->rc.range = range; > > > > LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState); > > > > range = p->rc.range; > > > > @@ -1888,7 +1888,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState) > > } > > > > while (--numBits); > > > > } > > > > - > > > > + > > > > { > > > > // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask); > > > > CLzmaProb *probs = p->posAlignEncoder; > > > > @@ -2037,7 +2037,7 @@ void LzmaEnc_Construct(CLzmaEnc *p) > > { > > > > RangeEnc_Construct(&p->rc); > > > > MatchFinder_Construct(&p->matchFinderBase); > > > > - > > > > + > > > > #ifndef _7ZIP_ST > > > > MatchFinderMt_Construct(&p->matchFinderMt); > > > > p->matchFinderMt.MatchFinder = &p->matchFinderBase; > > > > @@ -2081,7 +2081,7 @@ void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig) > > #ifndef _7ZIP_ST > > > > MatchFinderMt_Destruct(&p->matchFinderMt, allocBig); > > > > #endif > > > > - > > > > + > > > > MatchFinder_Free(&p->matchFinderBase, allocBig); > > > > LzmaEnc_FreeLits(p, alloc); > > > > RangeEnc_Free(&p->rc, alloc); > > > > @@ -2126,14 +2126,14 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > } > > > > > > > > if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0) > > > > - > > > > + > > > > for (;;) > > > > { > > > > UInt32 dist; > > > > unsigned len, posState; > > > > UInt32 range, ttt, newBound; > > > > CLzmaProb *probs; > > > > - > > > > + > > > > if (p->fastMode) > > > > len = GetOptimumFast(p); > > > > else > > > > @@ -2153,9 +2153,9 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > posState = (unsigned)nowPos32 & p->pbMask; > > > > range = p->rc.range; > > > > probs = &p->isMatch[p->state][posState]; > > > > - > > > > + > > > > RC_BIT_PRE(&p->rc, probs) > > > > - > > > > + > > > > dist = p->backRes; > > > > > > > > #ifdef SHOW_STAT2 > > > > @@ -2185,7 +2185,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > RC_BIT_1(&p->rc, probs); > > > > probs = &p->isRep[p->state]; > > > > RC_BIT_PRE(&p->rc, probs) > > > > - > > > > + > > > > if (dist < LZMA_NUM_REPS) > > > > { > > > > RC_BIT_1(&p->rc, probs); > > > > @@ -2269,7 +2269,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > p->reps[2] = p->reps[1]; > > > > p->reps[1] = p->reps[0]; > > > > p->reps[0] = dist + 1; > > > > - > > > > + > > > > p->matchPriceCount++; > > > > GetPosSlot(dist, posSlot); > > > > // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot); > > > > @@ -2287,7 +2287,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > while (symbol < (1 << kNumPosSlotBits * 2)); > > > > p->rc.range = range; > > > > } > > > > - > > > > + > > > > if (dist >= kStartPosModelIndex) > > > > { > > > > unsigned footerBits = ((posSlot >> 1) - 1); > > > > @@ -2340,7 +2340,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > > > > > nowPos32 += len; > > > > p->additionalOffset -= len; > > > > - > > > > + > > > > if (p->additionalOffset == 0) > > > > { > > > > UInt32 processed; > > > > @@ -2352,11 +2352,11 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa > > if (p->alignPriceCount >= kAlignTableSize) > > > > FillAlignPrices(p); > > > > } > > > > - > > > > + > > > > if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0) > > > > break; > > > > processed = nowPos32 - startPos32; > > > > - > > > > + > > > > if (maxPackSize) > > > > { > > > > if (processed + kNumOpts + 300 >= maxUnpackSize > > > > @@ -2430,7 +2430,7 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, > > p->matchFinderObj = &p->matchFinderBase; > > > > MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder); > > > > } > > > > - > > > > + > > > > return SZ_OK; > > > > } > > > > > > > > @@ -2644,7 +2644,7 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit, > > return SZ_ERROR_OUTPUT_EOF; > > > > > > > > res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize); > > > > - > > > > + > > > > *unpackSize = (UInt32)(p->nowPos64 - nowPos64); > > > > *destLen -= outStream.rem; > > > > if (outStream.overflow) > > > > @@ -2679,7 +2679,7 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress) > > } > > > > } > > > > } > > > > - > > > > + > > > > LzmaEnc_Finish(p); > > > > > > > > /* > > > > @@ -2751,7 +2751,7 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte > > p->rc.outStream = &outStream.vt; > > > > > > > > res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig); > > > > - > > > > + > > > > if (res == SZ_OK) > > > > { > > > > res = LzmaEnc_Encode2(p, progress); > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c > > index 8fd86f224be7..9a29839fe8fe 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c > > @@ -34,9 +34,9 @@ WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE) > > WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param) > > > > { > > > > /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */ > > > > - > > > > + > > > > #ifdef UNDER_CE > > > > - > > > > + > > > > DWORD threadId; > > > > *p = CreateThread(0, 0, func, param, 0, &threadId); > > > > > > > > @@ -44,7 +44,7 @@ WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param) > > > > > > unsigned threadId; > > > > *p = (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId); > > > > - > > > > + > > > > #endif > > > > > > > > /* maybe we must use errno here, but probably GetLastError() is also OK. */ > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > > index d7426d38a4dd..a8d75ed7095d 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt > > @@ -3,11 +3,11 @@ HISTORY of the LZMA SDK > > > > > > 18.05 2018-04-30 > > > > ------------------------- > > > > -- The speed for LZMA/LZMA2 compressing was increased > > > > - by 8% for fastest/fast compression levels and > > > > +- The speed for LZMA/LZMA2 compressing was increased > > > > + by 8% for fastest/fast compression levels and > > > > by 3% for normal/maximum compression levels. > > > > - Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in > > > > - Windows 10 because of some BUG with "Large Pages" in Windows 10. > > > > + Windows 10 because of some BUG with "Large Pages" in Windows 10. > > > > Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299). > > > > - The BUG was fixed in Lzma2Enc.c > > > > Lzma2Enc_Encode2() function worked incorretly, > > > > @@ -16,7 +16,7 @@ HISTORY of the LZMA SDK > > > > > > 18.03 beta 2018-03-04 > > > > ------------------------- > > > > -- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm > > > > +- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm > > > > for x64 with about 30% higher speed than main version of LZMA decoder written in C. > > > > - The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%. > > > > - 7-Zip now can use multi-threading for 7z/LZMA2 decoding, > > > > @@ -35,7 +35,7 @@ HISTORY of the LZMA SDK > > 18.00 beta 2019-01-10 > > > > ------------------------- > > > > - The BUG in xz encoder was fixed: > > > > - There was memory leak of 16 KB for each file compressed with > > > > + There was memory leak of 16 KB for each file compressed with > > > > xz compression method, if additional filter was used. > > > > > > > > > > > > @@ -44,7 +44,7 @@ HISTORY of the LZMA SDK > > - Minor speed optimization for LZMA2 (xz and 7z) multi-threading compression. > > > > 7-Zip now uses additional memory buffers for multi-block LZMA2 compression. > > > > CPU utilization was slightly improved. > > > > -- 7-zip now creates multi-block xz archives by default. Block size can be > > > > +- 7-zip now creates multi-block xz archives by default. Block size can be > > > > specified with -ms[Size]{m|g} switch. > > > > - xz decoder now can unpack random block from multi-block xz archives. > > > > - 7-Zip command line: @listfile now doesn't work after -- switch. > > > > @@ -55,7 +55,7 @@ HISTORY of the LZMA SDK > > > > > > 17.00 beta 2017-04-29 > > > > ------------------------- > > > > -- NewHandler.h / NewHandler.cpp: > > > > +- NewHandler.h / NewHandler.cpp: > > > > now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900). > > > > - C/7zTypes.h : the names of variables in interface structures were changed (vt). > > > > - Some bugs were fixed. 7-Zip could crash in some cases. > > > > @@ -76,51 +76,51 @@ HISTORY of the LZMA SDK > > 16.02 2016-05-21 > > > > ------------------------- > > > > - The BUG in 16.00 - 16.01 was fixed: > > > > - Split Handler (SplitHandler.cpp) returned incorrect > > > > + Split Handler (SplitHandler.cpp) returned incorrect > > > > total size value (kpidSize) for split archives. > > > > > > > > > > > > 16.01 2016-05-19 > > > > -------------------------- > > > > +------------------------- > > > > - Some internal changes to reduce the number of compiler warnings. > > > > > > > > > > > > 16.00 2016-05-10 > > > > -------------------------- > > > > +------------------------- > > > > - Some bugs were fixed. > > > > > > > > > > > > 15.12 2015-11-19 > > > > -------------------------- > > > > +------------------------- > > > > - The BUG in C version of 7z decoder was fixed: > > > > 7zDec.c : SzDecodeLzma2() > > > > 7z decoder could mistakenly report about decoding error for some 7z archives > > > > that use LZMA2 compression method. > > > > - The probability to get that mistaken decoding error report was about > > > > - one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size). > > > > + The probability to get that mistaken decoding error report was about > > > > + one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size). > > > > - The BUG (in 9.26-15.11) in C version of 7z decoder was fixed: > > > > 7zArcIn.c : SzReadHeader2() > > > > - 7z decoder worked incorrectly for 7z archives that contain > > > > - empty solid blocks, that can be placed to 7z archive, if some file is > > > > + 7z decoder worked incorrectly for 7z archives that contain > > > > + empty solid blocks, that can be placed to 7z archive, if some file is > > > > unavailable for reading during archive creation. > > > > > > > > > > > > 15.09 beta 2015-10-16 > > > > -------------------------- > > > > +------------------------- > > > > - The BUG in LZMA / LZMA2 encoding code was fixed. > > > > The BUG in LzFind.c::MatchFinder_ReadBlock() function. > > > > If input data size is larger than (4 GiB - dictionary_size), > > > > the following code worked incorrectly: > > > > - - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions > > > > - for compressing from memory to memory. > > > > + - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions > > > > + for compressing from memory to memory. > > > > That BUG is not related to LZMA encoder version that works via streams. > > > > - - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if > > > > - default value of chunk size (CLzma2EncProps::blockSize) is changed > > > > + - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if > > > > + default value of chunk size (CLzma2EncProps::blockSize) is changed > > > > to value larger than (4 GiB - dictionary_size). > > > > > > > > > > > > 9.38 beta 2015-01-03 > > > > -------------------------- > > > > +------------------------- > > > > - The BUG in 9.31-9.37 was fixed: > > > > IArchiveGetRawProps interface was disabled for 7z archives. > > > > - The BUG in 9.26-9.36 was fixed: > > > > @@ -128,10 +128,10 @@ HISTORY of the LZMA SDK > > > > > > > > > > 9.36 beta 2014-12-26 > > > > -------------------------- > > > > +------------------------- > > > > - The BUG in command line version was fixed: > > > > 7-Zip created temporary archive in current folder during update archive > > > > - operation, if -w{Path} switch was not specified. > > > > + operation, if -w{Path} switch was not specified. > > > > The fixed 7-Zip creates temporary archive in folder that contains updated archive. > > > > - The BUG in 9.33-9.35 was fixed: > > > > 7-Zip silently ignored file reading errors during 7z or gz archive creation, > > > > @@ -140,14 +140,14 @@ HISTORY of the LZMA SDK > > > > > > > > > > 9.35 beta 2014-12-07 > > > > -------------------------- > > > > +------------------------- > > > > - 7zr.exe now support AES encryption. > > > > - SFX modules were added to LZMA SDK > > > > - Some bugs were fixed. > > > > > > > > > > > > 9.21 beta 2011-04-11 > > > > -------------------------- > > > > +------------------------- > > > > - New class FString for file names at file systems. > > > > - Speed optimization in CRC code for big-endian CPUs. > > > > - The BUG in Lzma2Dec.c was fixed: > > > > @@ -155,7 +155,7 @@ HISTORY of the LZMA SDK > > > > > > > > > > 9.18 beta 2010-11-02 > > > > -------------------------- > > > > +------------------------- > > > > - New small SFX module for installers (SfxSetup). > > > > > > > > > > > > @@ -168,7 +168,7 @@ HISTORY of the LZMA SDK > > 9.11 beta 2010-03-15 > > > > ------------------------- > > > > - PPMd compression method support > > > > - > > > > + > > > > > > > > 9.09 2009-12-12 > > > > ------------------------- > > > > @@ -202,7 +202,7 @@ HISTORY of the LZMA SDK > > 4.61 beta 2008-11-23 > > > > ------------------------- > > > > - The bug in ANSI-C LZMA Decoder was fixed: > > > > - If encoded stream was corrupted, decoder could access memory > > > > + If encoded stream was corrupted, decoder could access memory > > > > outside of allocated range. > > > > - Some changes in ANSI-C 7z Decoder interfaces. > > > > - LZMA SDK is placed in the public domain. > > > > @@ -216,7 +216,7 @@ HISTORY of the LZMA SDK > > 4.59 beta 2008-08-13 > > > > ------------------------- > > > > - The bug was fixed: > > > > - LZMA Encoder in fast compression mode could access memory outside of > > > > + LZMA Encoder in fast compression mode could access memory outside of > > > > allocated range in some rare cases. > > > > > > > > > > > > @@ -229,7 +229,7 @@ HISTORY of the LZMA SDK > > > > > > 4.57 2007-12-12 > > > > ------------------------- > > > > -- Speed optimizations in ?++ LZMA Decoder. > > > > +- Speed optimizations in ?++ LZMA Decoder. > > > > - Small changes for more compatibility with some C/C++ compilers. > > > > > > > > > > > > @@ -239,36 +239,36 @@ HISTORY of the LZMA SDK > > - now it supports BCJ and BCJ2 filters > > > > - now it supports files larger than 4 GB. > > > > - now it supports "Last Write Time" field for files. > > > > -- C++ code for .7z archives compressing/decompressing from 7-zip > > > > +- C++ code for .7z archives compressing/decompressing from 7-zip > > > > was included to LZMA SDK. > > > > - > > > > + > > > > > > > > 4.43 2006-06-04 > > > > ------------------------- > > > > - Small changes for more compatibility with some C/C++ compilers. > > > > - > > > > + > > > > > > > > 4.42 2006-05-15 > > > > ------------------------- > > > > - Small changes in .h files in ANSI-C version. > > > > - > > > > + > > > > > > > > 4.39 beta 2006-04-14 > > > > ------------------------- > > > > - The bug in versions 4.33b:4.38b was fixed: > > > > - C++ version of LZMA encoder could not correctly compress > > > > + C++ version of LZMA encoder could not correctly compress > > > > files larger than 2 GB with HC4 match finder (-mfhc4). > > > > - > > > > + > > > > > > > > 4.37 beta 2005-04-06 > > > > ------------------------- > > > > -- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined. > > > > +- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined. > > > > > > > > > > > > 4.35 beta 2005-03-02 > > > > ------------------------- > > > > - The bug was fixed in C++ version of LZMA Decoder: > > > > - If encoded stream was corrupted, decoder could access memory > > > > + If encoded stream was corrupted, decoder could access memory > > > > outside of allocated range. > > > > > > > > > > > > @@ -339,7 +339,7 @@ HISTORY of the LZMA SDK > > > > > > 4.17 2005-04-18 > > > > ------------------------- > > > > -- New example for RAM->RAM compressing/decompressing: > > > > +- New example for RAM->RAM compressing/decompressing: > > > > LZMA + BCJ (filter for x86 code): > > > > - LzmaRam.h > > > > - LzmaRam.cpp > > > > @@ -350,11 +350,11 @@ HISTORY of the LZMA SDK > > > > > > 4.16 2005-03-29 > > > > ------------------------- > > > > -- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder): > > > > +- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder): > > > > If _LZMA_OUT_READ was defined, and if encoded stream was corrupted, > > > > decoder could access memory outside of allocated range. > > > > - Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster). > > > > - Old version of LZMA Decoder now is in file LzmaDecodeSize.c. > > > > + Old version of LZMA Decoder now is in file LzmaDecodeSize.c. > > > > LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c > > > > - Small speed optimization in LZMA C++ code > > > > - filter for SPARC's code was added > > > > @@ -369,7 +369,7 @@ HISTORY of the LZMA SDK > > > > > > 4.05 2004-08-25 > > > > ------------------------- > > > > -- Source code of filters for x86, IA-64, ARM, ARM-Thumb > > > > +- Source code of filters for x86, IA-64, ARM, ARM-Thumb > > > > and PowerPC code was included to SDK > > > > - Some internal minor changes > > > > > > > > @@ -381,8 +381,8 @@ HISTORY of the LZMA SDK > > > > > > 4.03 2004-06-18 > > > > ------------------------- > > > > -- "Benchmark" command was added. It measures compressing > > > > - and decompressing speed and shows rating values. > > > > +- "Benchmark" command was added. It measures compressing > > > > + and decompressing speed and shows rating values. > > > > Also it checks hardware errors. > > > > > > > > > > > > @@ -411,7 +411,7 @@ HISTORY of the LZMA SDK > > > > > > HISTORY of the LZMA > > > > ------------------- > > > > - 2001-2008: Improvements to LZMA compressing/decompressing code, > > > > + 2001-2008: Improvements to LZMA compressing/decompressing code, > > > > keeping compatibility with original LZMA format > > > > 1996-2001: Development of LZMA compression format > > > > > > > > @@ -419,6 +419,6 @@ HISTORY of the LZMA > > > > > > 2001-08-30: LZMA compression was added to 7-Zip > > > > 1999-01-02: First version of 7-Zip was released > > > > - > > > > + > > > > > > > > End of document > > > > diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > > index a3deb2094335..914bd19e90be 100644 > > --- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > > +++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt > > @@ -2,15 +2,15 @@ LZMA SDK 18.05 > > -------------- > > > > > > > > LZMA SDK provides the documentation, samples, header files, > > > > -libraries, and tools you need to develop applications that > > > > +libraries, and tools you need to develop applications that > > > > use 7z / LZMA / LZMA2 / XZ compression. > > > > > > > > -LZMA is an improved version of famous LZ77 compression algorithm. > > > > +LZMA is an improved version of famous LZ77 compression algorithm. > > > > It was improved in way of maximum increasing of compression ratio, > > > > -keeping high decompression speed and low memory requirements for > > > > +keeping high decompression speed and low memory requirements for > > > > decompressing. > > > > > > > > -LZMA2 is a LZMA based compression method. LZMA2 provides better > > > > +LZMA2 is a LZMA based compression method. LZMA2 provides better > > > > multithreading support for compression than LZMA and some other improvements. > > > > > > > > 7z is a file format for data compression and file archiving. > > > > @@ -19,7 +19,7 @@ multithreading support for compression than LZMA and some other improvements. > > 7z also supports AES-256 based encryption. > > > > > > > > XZ is a file format for data compression that uses LZMA2 compression. > > > > -XZ format provides additional features: SHA/CRC check, filters for > > > > +XZ format provides additional features: SHA/CRC check, filters for > > > > improved compression ratio, splitting to blocks and streams, > > > > > > > > > > > > @@ -33,11 +33,11 @@ Some code in LZMA SDK is based on public domain code from another developers: > > 1) PPMd var.H (2001): Dmitry Shkarin > > > > 2) SHA-256: Wei Dai (Crypto++ library) > > > > > > > > -Anyone is free to copy, modify, publish, use, compile, sell, or distribute the > > > > -original LZMA SDK code, either in source code form or as a compiled binary, for > > > > +Anyone is free to copy, modify, publish, use, compile, sell, or distribute the > > > > +original LZMA SDK code, either in source code form or as a compiled binary, for > > > > any purpose, commercial or non-commercial, and by any means. > > > > > > > > -LZMA SDK code is compatible with open source licenses, for example, you can > > > > +LZMA SDK code is compatible with open source licenses, for example, you can > > > > include it to GNU GPL or GNU LGPL code. > > > > > > > > > > > > @@ -60,7 +60,7 @@ LZMA SDK Contents > > - SFX modules for installers. > > > > > > > > > > > > -UNIX/Linux version > > > > +UNIX/Linux version > > > > ------------------ > > > > To compile C++ version of file->file LZMA encoding, go to directory > > > > CPP/7zip/Bundles/LzmaCon > > > > @@ -68,11 +68,11 @@ and call make to recompile it: > > make -f makefile.gcc clean all > > > > > > > > In some UNIX/Linux versions you must compile LZMA with static libraries. > > > > -To compile with static libraries, you can use > > > > +To compile with static libraries, you can use > > > > LIB = -lm -static > > > > > > > > Also you can use p7zip (port of 7-Zip for POSIX systems like Unix or Linux): > > > > - > > > > + > > > > http://p7zip.sourceforge.net/ > > > > > > > > > > > > @@ -120,7 +120,7 @@ C/ - C files (compression / decompression and other) > > 7z - 7z decoder program (decoding 7z files) > > > > Lzma - LZMA program (file->file LZMA encoder/decoder). > > > > LzmaLib - LZMA library (.DLL for Windows) > > > > - SfxSetup - small SFX module for installers > > > > + SfxSetup - small SFX module for installers > > > > > > > > CPP/ -- CPP files > > > > > > > > @@ -135,7 +135,7 @@ CPP/ -- CPP files > > 7z - 7z C++ Encoder/Decoder > > > > > > > > Bundles - Modules that are bundles of other modules (files) > > > > - > > > > + > > > > Alone7z - 7zr.exe: Standalone 7-Zip console program (reduced version) > > > > Format7zExtractR - 7zxr.dll: Reduced version of 7z DLL: extracting from 7z/LZMA/BCJ/BCJ2. > > > > Format7zR - 7zr.dll: Reduced version of 7z DLL: extracting/compressing to 7z/LZMA/BCJ/BCJ2 > > > > @@ -152,7 +152,7 @@ CPP/ -- CPP files > > Crypto - files for encryption / decompression > > > > > > > > UI - User Interface files > > > > - > > > > + > > > > Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll > > > > Common - Common UI files > > > > Console - Code for console program (7z.exe) > > > > @@ -178,7 +178,7 @@ Java/ - Java files > > RangeCoder - Range Coder (special code of compression/decompression) > > > > > > > > > > > > -Note: > > > > +Note: > > > > Asm / C / C++ source code of LZMA SDK is part of 7-Zip's source code. > > > > 7-Zip's source code can be downloaded from 7-Zip's SourceForge page: > > > > > > > > @@ -190,13 +190,13 @@ LZMA features > > ------------- > > > > - Variable dictionary size (up to 1 GB) > > > > - Estimated compressing speed: about 2 MB/s on 2 GHz CPU > > > > - - Estimated decompressing speed: > > > > + - Estimated decompressing speed: > > > > - 20-30 MB/s on modern 2 GHz cpu > > > > - 1-2 MB/s on 200 MHz simple RISC cpu: (ARM, MIPS, PowerPC) > > > > - Small memory requirements for decompressing (16 KB + DictionarySize) > > > > - Small code size for decompressing: 5-8 KB > > > > > > > > -LZMA decoder uses only integer operations and can be > > > > +LZMA decoder uses only integer operations and can be > > > > implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions). > > > > > > > > Some critical operations that affect the speed of LZMA decompression: > > > > @@ -205,7 +205,7 @@ Some critical operations that affect the speed of LZMA decompression: > > 3) 32-bit shift and arithmetic operations > > > > > > > > The speed of LZMA decompressing mostly depends from CPU speed. > > > > -Memory speed has no big meaning. But if your CPU has small data cache, > > > > +Memory speed has no big meaning. But if your CPU has small data cache, > > > > overall weight of memory speed will slightly increase. > > > > > > > > > > > > @@ -221,53 +221,53 @@ Usage: LZMA inputFile outputFile [...] > > > > > > 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. > > > > > > > > > > > > - > > > > + > > > > > > > > -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 inputFile outputFile [...] > > 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 inputFile outputFile [...] > > > > > > 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 > > > > <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_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 resulted > > > > + _setjmp. A later effort to execute #include 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 > > > > #else > > > > @@ -1492,7 +1492,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS > > #endif > > > > > > > > #endif > > > > - > > > > + > > > > A similar change has been made for other standard header files > > > > required by pccts and sorcerer: stdlib.h, stdarg.h, stdio.h, etc. > > > > > > > > @@ -1522,13 +1522,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS > > > > > > if ($$.letter > $2.letter) { > > > > error("invalid range ", zzline); > > > > - } > > > > + } > > > > > > > > The fix is: > > > > > > > > if ($$.letter > $2.letter && 255 != $$2.letter) { > > > > error("invalid range ", zzline); > > > > - } > > > > + } > > > > > > > > #206. (Changed in MR16) Free zzFAILtext in ANTLRParser destructor > > > > > > > > @@ -1544,7 +1544,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS > > Suggested by Dale Davis (daldavis spectrace.com) > > > > > > > > #204. (Changed in MR15a) Change __WATCOM__ to __WATCOMC__ in pcctscfg.h > > > > - > > > > + > > > > Reported by Oleg Dashevskii (olegdash my-dejanews.com). > > > > > > > > #203. (Changed in MR15) Addition of sorcerer to distribution kit > > > > @@ -1562,7 +1562,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS > > .cpp files in the pccts/h directory. > > > > > > > > The library build will create pccts_debug.lib or pccts_release.lib > > > > - according to the configuration selected. > > > > + according to the configuration selected. > > > > > > > > If you don't want to build pccts 1.33MR15 you can download a > > > > ready-to-run kit for win32 from http://www.polhode.com/win32.zip. > > > > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt > > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt > > index 33d7d20a6a3c..b95615d8a3c1 100644 > > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt > > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt > > @@ -2143,7 +2143,7 @@ > > > > > > -------------------------------------------------- > > > > Note: This was incorrect. The contexts should be > > > > - ORed together. This has been fixed. A more > > > > + ORed together. This has been fixed. A more > > > > complete description is available in item #152. > > > > --------------------------------------------------- > > > > > > > > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt > > b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt > > index 7134500e2fbf..2c371954661f 100644 > > --- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt > > +++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt > > @@ -42,9 +42,9 @@ > > > > > > #216. Defer token fetch for C++ mode > > > > > > > > - When the ANTLRParser class is built with the pre-processor option > > > > + When the ANTLRParser class is built with the pre-processor option > > > > ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred > > > > - until LA(i) or LT(i) is called. > > > > + until LA(i) or LT(i) is called. > > > > > > > > #215. Use reset() to reset DLGLexerBase > > > > #188. Added pccts/h/DLG_stream_input.h > > > > @@ -1684,7 +1684,7 @@ > > > > > > -------------------------------------------------- > > > > Note: This was incorrect. The contexts should be > > > > - ORed together. This has been fixed. A more > > > > + ORed together. This has been fixed. A more > > > > complete description is available in item #152. > > > > --------------------------------------------------- > > > > > > > > diff --git a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt > > index 539cf775257b..cc5cad73897e 100644 > > --- a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt > > +++ b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt > > @@ -8,28 +8,28 @@ > > See item #207. > > > > > > > > Reported by Frank Hartmann. > > > > - > > > > + > > > > #16. A note about "&&" predicates (Mike Dimmick) > > > > > > > > Mike Dimmick has pointed out a potential pitfall in the use of the > > > > "&&" style predicate. Consider: > > > > - > > > > + > > > > r0: (g)? => <

>? 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 > > > (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 > > > > "" 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 * 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 * 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] > > > "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 > > > - > > > > + > > > > 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 >