Re: [Patch 1/2] OvmfPkg: Change default to disable MptScsi and PvScsi
Gerd Hoffmann
On Mon, Dec 05, 2022 at 04:36:15PM -0700, dann frazier wrote:
On Tue, Jul 26, 2022 at 12:46:39PM -0700, Michael D Kinney wrote:I'm not so sure about that.The email addresses for the reviewers of the MptScsi andHi Michael, The bug report talks about lsilogic and virtio-scsi.- DEFINE PVSCSI_ENABLE = TRUE lsilogic was already disabled by default before this patch. virtio-scsi support is included and there are no plans to change that because it is a rather essential driver. It works just fine upstream, and there isn't even a config switch to disable it. take care, Gerd |
|
[PATCH 2/2] EmulatorPkg: Record Argc, Argv and Envp in EmuThunk Ppi
Zhiguang Liu
Record Argc, Argv and Envp in EmuThunk Ppi so that other modules
can use these fields to change behavior depends on boot parameters or environment. Cc: Andrew Fish <afish@...> Cc: Ray Ni <ray.ni@...> Signed-off-by: Zhiguang Liu <zhiguang.liu@...> --- EmulatorPkg/Include/Ppi/EmuThunk.h | 3 +++ EmulatorPkg/Unix/Host/Host.c | 3 +++ EmulatorPkg/Win/Host/WinHost.c | 3 +++ 3 files changed, 9 insertions(+) diff --git a/EmulatorPkg/Include/Ppi/EmuThunk.h b/EmulatorPkg/Include/Ppi/EmuThunk.h index cf29cf824c..c78ad692ed 100644 --- a/EmulatorPkg/Include/Ppi/EmuThunk.h +++ b/EmulatorPkg/Include/Ppi/EmuThunk.h @@ -107,6 +107,9 @@ typedef struct { EMU_PEI_AUTOSCAN MemoryAutoScan; EMU_PEI_FD_INFORMATION FirmwareDevices; EMU_PEI_THUNK_INTERFACE Thunk; + INTN Argc; + CHAR8 **Argv; + CHAR8 **Envp; UINTN PersistentMemorySize; UINT8 PersistentMemory[0]; } EMU_THUNK_PPI; diff --git a/EmulatorPkg/Unix/Host/Host.c b/EmulatorPkg/Unix/Host/Host.c index 8d0be5b54b..1f29dd00a3 100644 --- a/EmulatorPkg/Unix/Host/Host.c +++ b/EmulatorPkg/Unix/Host/Host.c @@ -145,6 +145,9 @@ main ( } CopyMem (SecEmuThunkPpi, &mSecEmuThunkPpi, sizeof (EMU_THUNK_PPI)); + SecEmuThunkPpi->Argc = Argc; + SecEmuThunkPpi->Argv = Argv; + SecEmuThunkPpi->Envp = Envp; SecEmuThunkPpi->PersistentMemorySize = FixedPcdGet32 (PcdPersistentMemorySize); AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, SecEmuThunkPpi); diff --git a/EmulatorPkg/Win/Host/WinHost.c b/EmulatorPkg/Win/Host/WinHost.c index 3b2fde297d..f639ba3b1b 100644 --- a/EmulatorPkg/Win/Host/WinHost.c +++ b/EmulatorPkg/Win/Host/WinHost.c @@ -485,6 +485,9 @@ Returns: } CopyMem (SecEmuThunkPpi, &mSecEmuThunkPpi, sizeof (EMU_THUNK_PPI)); + SecEmuThunkPpi->Argc = Argc; + SecEmuThunkPpi->Argv = Argv; + SecEmuThunkPpi->Envp = Envp; SecEmuThunkPpi->PersistentMemorySize = FixedPcdGet32 (PcdPersistentMemorySize); AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, SecEmuThunkPpi); AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEfiPeiReset2PpiGuid, &mEmuReset2Ppi); -- 2.31.1.windows.1 |
|
[PATCH 1/2] EmulatorPkg: Add persistent memory in EmuThunkPpi
Zhiguang Liu
The persistent memory is for PEIM to use, and won't lose during cold
or warm reset. PcdPersistentMemorySize is only used by WinHost.c, other modules can check the persistent memory size using the field PersistentMemorySize. Cc: Andrew Fish <afish@...> Cc: Ray Ni <ray.ni@...> Signed-off-by: Zhiguang Liu <zhiguang.liu@...> --- EmulatorPkg/EmulatorPkg.dec | 3 ++- EmulatorPkg/Include/Ppi/EmuThunk.h | 4 +++- EmulatorPkg/Unix/Host/Host.c | 13 +++++++++++-- EmulatorPkg/Unix/Host/Host.inf | 3 ++- EmulatorPkg/Win/Host/WinHost.c | 11 ++++++++++- EmulatorPkg/Win/Host/WinHost.inf | 2 +- 6 files changed, 29 insertions(+), 7 deletions(-) diff --git a/EmulatorPkg/EmulatorPkg.dec b/EmulatorPkg/EmulatorPkg.dec index b9c70b63b3..fe81652b04 100644 --- a/EmulatorPkg/EmulatorPkg.dec +++ b/EmulatorPkg/EmulatorPkg.dec @@ -2,7 +2,7 @@ # # This is the Emu Emulation Environment Platform # -# Copyright (c) 2008 - 2019, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2008 - 2022, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2011, Apple Inc. All rights reserved. # (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR> # @@ -86,6 +86,7 @@ # The user ID and password are fixed as below. gEmulatorPkgTokenSpaceGuid.PcdRedfishServieUserId|"admin"|VOID*|0x00001022 gEmulatorPkgTokenSpaceGuid.PcdRedfishServiePassword|"pwd123456"|VOID*|0x00001023 + gEmulatorPkgTokenSpaceGuid.PcdPersistentMemorySize|0x4000000|UINT32|0x00001024 [PcdsFixedAtBuild, PcdsPatchableInModule] gEmulatorPkgTokenSpaceGuid.PcdEmuBootMode|1|UINT32|0x00001006 diff --git a/EmulatorPkg/Include/Ppi/EmuThunk.h b/EmulatorPkg/Include/Ppi/EmuThunk.h index c0e2bc6b98..cf29cf824c 100644 --- a/EmulatorPkg/Include/Ppi/EmuThunk.h +++ b/EmulatorPkg/Include/Ppi/EmuThunk.h @@ -2,7 +2,7 @@ Emulator Thunk to abstract OS services from pure EFI code Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR> - + Copyright (c) 2022, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ @@ -107,6 +107,8 @@ typedef struct { EMU_PEI_AUTOSCAN MemoryAutoScan; EMU_PEI_FD_INFORMATION FirmwareDevices; EMU_PEI_THUNK_INTERFACE Thunk; + UINTN PersistentMemorySize; + UINT8 PersistentMemory[0]; } EMU_THUNK_PPI; extern EFI_GUID gEmuThunkPpiGuid; diff --git a/EmulatorPkg/Unix/Host/Host.c b/EmulatorPkg/Unix/Host/Host.c index 38c01c84af..8d0be5b54b 100644 --- a/EmulatorPkg/Unix/Host/Host.c +++ b/EmulatorPkg/Unix/Host/Host.c @@ -1,6 +1,6 @@ /*++ @file -Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR> +Copyright (c) 2006 - 2022, Intel Corporation. All rights reserved.<BR> Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent @@ -102,6 +102,7 @@ main ( CHAR16 *FirmwareVolumesStr; UINTN *StackPointer; FILE *GdbTempFile; + EMU_THUNK_PPI *SecEmuThunkPpi; // // Xcode does not support sourcing gdb scripts directly, so the Xcode XML @@ -137,7 +138,15 @@ main ( // // PPIs pased into PEI_CORE // - AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, &mSecEmuThunkPpi); + SecEmuThunkPpi = AllocateZeroPool (sizeof (EMU_THUNK_PPI) + FixedPcdGet32 (PcdPersistentMemorySize)); + if (SecEmuThunkPpi == NULL) { + printf ("ERROR : Can not allocate memory for SecEmuThunkPpi. Exiting.\n"); + exit (1); + } + + CopyMem (SecEmuThunkPpi, &mSecEmuThunkPpi, sizeof (EMU_THUNK_PPI)); + SecEmuThunkPpi->PersistentMemorySize = FixedPcdGet32 (PcdPersistentMemorySize); + AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, SecEmuThunkPpi); SecInitThunkProtocol (); diff --git a/EmulatorPkg/Unix/Host/Host.inf b/EmulatorPkg/Unix/Host/Host.inf index c479d2b7d0..f5ebbed683 100644 --- a/EmulatorPkg/Unix/Host/Host.inf +++ b/EmulatorPkg/Unix/Host/Host.inf @@ -2,7 +2,7 @@ # Entry Point of Emu Emulator # # Main executable file of Unix Emulator that loads PEI core after initialization finished. -# Copyright (c) 2008 - 2019, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2008 - 2022, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR> # # SPDX-License-Identifier: BSD-2-Clause-Patent @@ -106,6 +106,7 @@ gEmulatorPkgTokenSpaceGuid.PcdEmuFlashNvStorageFtwSpareBase gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage + gEmulatorPkgTokenSpaceGuid.PcdPersistentMemorySize [FeaturePcd] gEmulatorPkgTokenSpaceGuid.PcdEmulatorLazyLoadSymbols diff --git a/EmulatorPkg/Win/Host/WinHost.c b/EmulatorPkg/Win/Host/WinHost.c index 096292f95a..3b2fde297d 100644 --- a/EmulatorPkg/Win/Host/WinHost.c +++ b/EmulatorPkg/Win/Host/WinHost.c @@ -436,6 +436,7 @@ Returns: UINTN SystemAffinityMask; INT32 LowBit; UINTN ResetJumpCode; + EMU_THUNK_PPI *SecEmuThunkPpi; // // Enable the privilege so that RTC driver can successfully run SetTime() @@ -477,7 +478,15 @@ Returns: // // PPIs pased into PEI_CORE // - AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, &mSecEmuThunkPpi); + SecEmuThunkPpi = AllocateZeroPool (sizeof (EMU_THUNK_PPI) + FixedPcdGet32 (PcdPersistentMemorySize)); + if (SecEmuThunkPpi == NULL) { + SecPrint ("ERROR : Can not allocate memory for SecEmuThunkPpi. Exiting.\n"); + exit (1); + } + + CopyMem (SecEmuThunkPpi, &mSecEmuThunkPpi, sizeof (EMU_THUNK_PPI)); + SecEmuThunkPpi->PersistentMemorySize = FixedPcdGet32 (PcdPersistentMemorySize); + AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, SecEmuThunkPpi); AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEfiPeiReset2PpiGuid, &mEmuReset2Ppi); // diff --git a/EmulatorPkg/Win/Host/WinHost.inf b/EmulatorPkg/Win/Host/WinHost.inf index b61901fae2..4dac6e033e 100644 --- a/EmulatorPkg/Win/Host/WinHost.inf +++ b/EmulatorPkg/Win/Host/WinHost.inf @@ -74,7 +74,7 @@ [Pcd] gEfiMdeModulePkgTokenSpaceGuid.PcdInitValueInTempStack - + gEmulatorPkgTokenSpaceGuid.PcdPersistentMemorySize gEmulatorPkgTokenSpaceGuid.PcdEmuBootMode gEmulatorPkgTokenSpaceGuid.PcdEmuFirmwareVolume gEmulatorPkgTokenSpaceGuid.PcdEmuMemorySize -- 2.31.1.windows.1 |
|
Re: [PATCH] UnitTestFrameworkPkg: Modify APIs in UnitTestPersistenceLib
Ni, Ray
Reviewed-by: Ray Ni <ray.ni@...>
toggle quoted message
Show quoted text
-----Original Message----- |
|
[PATCH] EmulatorPkg: Remove unnecessary dependency on EmbeddedPkg
Zhiguang Liu
EmulatorPkg doesn't need depend on EmbeddedPkg, so remove the dependency.
Cc: Andrew Fish <afish@...> Cc: Ray Ni <ray.ni@...> Signed-off-by: Zhiguang Liu <zhiguang.liu@...> --- EmulatorPkg/EmulatorPkg.ci.yaml | 3 +-- .../Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf | 3 +-- .../Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/EmulatorPkg/EmulatorPkg.ci.yaml b/EmulatorPkg/EmulatorPkg.ci.yaml index 338d5fc2d3..6e9b2857cb 100644 --- a/EmulatorPkg/EmulatorPkg.ci.yaml +++ b/EmulatorPkg/EmulatorPkg.ci.yaml @@ -5,7 +5,7 @@ # used for code analysis. # # Copyright (c) Microsoft Corporation -# Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2020 - 2022, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent ## { @@ -55,7 +55,6 @@ "EmulatorPkg/EmulatorPkg.dec", "NetworkPkg/NetworkPkg.dec", "RedfishPkg/RedfishPkg.dec", - "EmbeddedPkg/EmbeddedPkg.dec", ## is this one OK?? ], # For host based unit tests "AcceptableDependencies-HOST_APPLICATION":[ diff --git a/EmulatorPkg/Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf b/EmulatorPkg/Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf index d91f7de181..dfdabde22a 100644 --- a/EmulatorPkg/Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf +++ b/EmulatorPkg/Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf @@ -1,7 +1,7 @@ ## @file # Write only instance of Serial Port Library with empty functions. # -# Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2006 - 2022, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2011, Apple Inc. All rights reserved. # # SPDX-License-Identifier: BSD-2-Clause-Patent @@ -25,7 +25,6 @@ [Packages] MdePkg/MdePkg.dec EmulatorPkg/EmulatorPkg.dec - EmbeddedPkg/EmbeddedPkg.dec [LibraryClasses] EmuThunkLib diff --git a/EmulatorPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf b/EmulatorPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf index 2f5e656fd7..7ef3e3baaf 100644 --- a/EmulatorPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf +++ b/EmulatorPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf @@ -1,7 +1,7 @@ ## @file # Write only instance of Serial Port Library with empty functions. # -# Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2006 - 2022, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2011, Apple Inc. All rights reserved. # # SPDX-License-Identifier: BSD-2-Clause-Patent @@ -28,7 +28,6 @@ [Packages] MdePkg/MdePkg.dec EmulatorPkg/EmulatorPkg.dec - EmbeddedPkg/EmbeddedPkg.dec [LibraryClasses] PeiServicesLib -- 2.31.1.windows.1 |
|
[PATCH] UnitTestFrameworkPkg: Modify APIs in UnitTestPersistenceLib
Zhiguang Liu
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=4183
UnitTestPersistenceLib now consumes private struct definition. Modify APIs in UnitTestPersistenceLib to make it easy to become a public library. Cc: Michael D Kinney <michael.d.kinney@...> Cc: Michael Kubacki <mikuback@...> Cc: Sean Brogan <sean.brogan@...> Cc: Ray Ni <ray.ni@...> Signed-off-by: Zhiguang Liu <zhiguang.liu@...> --- .../Include/Library/UnitTestPersistenceLib.h | 14 +++++++---- .../Library/UnitTestLib/UnitTestLib.c | 6 +++-- .../UnitTestPersistenceLibNull.c | 11 ++++++--- .../UnitTestPersistenceLibSimpleFileSystem.c | 23 ++++++++++++------- 4 files changed, 36 insertions(+), 18 deletions(-) diff --git a/UnitTestFrameworkPkg/Include/Library/UnitTestPersistenceLib.h b/UnitTestFrameworkPkg/Include/Library/UnitTestPersistenceLib.h index be29e079ec..5543b79a0d 100644 --- a/UnitTestFrameworkPkg/Include/Library/UnitTestPersistenceLib.h +++ b/UnitTestFrameworkPkg/Include/Library/UnitTestPersistenceLib.h @@ -4,7 +4,7 @@ (eg. a reboot-based test). Copyright (c) Microsoft Corporation.<BR> - Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR> + Copyright (c) 2019 - 2022, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ @@ -12,7 +12,7 @@ #ifndef _UNIT_TEST_PERSISTENCE_LIB_H_ #define _UNIT_TEST_PERSISTENCE_LIB_H_ -#include <UnitTestFrameworkTypes.h> +#include <Library/UnitTestLib.h> #define UNIT_TEST_PERSISTENCE_LIB_VERSION 1 @@ -40,6 +40,7 @@ DoesCacheExist ( @param[in] FrameworkHandle A pointer to the framework that is being persisted. @param[in] SaveData A pointer to the buffer containing the serialized framework internal state. + @param[in] SaveStateSize The size of SaveData in bytes. @retval EFI_SUCCESS Data is persisted and the test can be safely quit. @retval Others Data is not persisted and test cannot be resumed upon exit. @@ -49,7 +50,8 @@ EFI_STATUS EFIAPI SaveUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - IN UNIT_TEST_SAVE_HEADER *SaveData + IN VOID *SaveData, + IN UINTN SaveStateSize ); /** @@ -57,8 +59,9 @@ SaveUnitTestCache ( Will allocate a buffer to hold the loaded data. @param[in] FrameworkHandle A pointer to the framework that is being persisted. - @param[in] SaveData A pointer pointer that will be updated with the address + @param[out] SaveData A pointer pointer that will be updated with the address of the loaded data buffer. + @param[out] SaveStateSize Return the size of SaveData in bytes. @retval EFI_SUCCESS Data has been loaded successfully and SaveData is updated with a pointer to the buffer. @@ -70,7 +73,8 @@ EFI_STATUS EFIAPI LoadUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - OUT UNIT_TEST_SAVE_HEADER **SaveData + OUT VOID **SaveData, + OUT UINTN *SaveStateSize ); #endif diff --git a/UnitTestFrameworkPkg/Library/UnitTestLib/UnitTestLib.c b/UnitTestFrameworkPkg/Library/UnitTestLib/UnitTestLib.c index 64d5880783..5b442ed122 100644 --- a/UnitTestFrameworkPkg/Library/UnitTestLib/UnitTestLib.c +++ b/UnitTestFrameworkPkg/Library/UnitTestLib/UnitTestLib.c @@ -2,6 +2,7 @@ Implement UnitTestLib Copyright (c) Microsoft Corporation. + Copyright (c) 2022, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ @@ -210,6 +211,7 @@ InitUnitTestFramework ( EFI_STATUS Status; UNIT_TEST_FRAMEWORK_HANDLE NewFrameworkHandle; UNIT_TEST_FRAMEWORK *NewFramework; + UINTN SaveStateSize; Status = EFI_SUCCESS; NewFramework = NULL; @@ -267,7 +269,7 @@ InitUnitTestFramework ( // If there is a persisted context, load it now. // if (DoesCacheExist (NewFrameworkHandle)) { - Status = LoadUnitTestCache (NewFrameworkHandle, (UNIT_TEST_SAVE_HEADER **)(&NewFramework->SavedState)); + Status = LoadUnitTestCache (NewFrameworkHandle, (VOID **)(&NewFramework->SavedState), &SaveStateSize); if (EFI_ERROR (Status)) { // // Don't actually report it as an error, but emit a warning. @@ -852,7 +854,7 @@ SaveFrameworkState ( // // All that should be left to do is save it using the associated persistence lib. // - Status = SaveUnitTestCache (FrameworkHandle, Header); + Status = SaveUnitTestCache (FrameworkHandle, Header, Header->SaveStateSize); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "%a - Could not save state! %r\n", __FUNCTION__, Status)); Status = EFI_DEVICE_ERROR; diff --git a/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibNull/UnitTestPersistenceLibNull.c b/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibNull/UnitTestPersistenceLibNull.c index e28327652e..abb24cff98 100644 --- a/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibNull/UnitTestPersistenceLibNull.c +++ b/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibNull/UnitTestPersistenceLibNull.c @@ -2,6 +2,7 @@ This is an instance of the Unit Test Persistence Lib that does nothing. Copyright (c) Microsoft Corporation.<BR> + Copyright (c) 2022, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ @@ -35,6 +36,7 @@ DoesCacheExist ( @param[in] FrameworkHandle A pointer to the framework that is being persisted. @param[in] SaveData A pointer to the buffer containing the serialized framework internal state. + @param[in] SaveStateSize The size of SaveData in bytes. @retval EFI_SUCCESS Data is persisted and the test can be safely quit. @retval Others Data is not persisted and test cannot be resumed upon exit. @@ -44,7 +46,8 @@ EFI_STATUS EFIAPI SaveUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - IN UNIT_TEST_SAVE_HEADER *SaveData + IN VOID *SaveData, + IN UINTN SaveStateSize ) { return EFI_UNSUPPORTED; @@ -55,8 +58,9 @@ SaveUnitTestCache ( Will allocate a buffer to hold the loaded data. @param[in] FrameworkHandle A pointer to the framework that is being persisted. - @param[in] SaveData A pointer pointer that will be updated with the address + @param[out] SaveData A pointer pointer that will be updated with the address of the loaded data buffer. + @param[out] SaveStateSize Return the size of SaveData in bytes. @retval EFI_SUCCESS Data has been loaded successfully and SaveData is updated with a pointer to the buffer. @@ -68,7 +72,8 @@ EFI_STATUS EFIAPI LoadUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - OUT UNIT_TEST_SAVE_HEADER **SaveData + OUT VOID **SaveData, + OUT UINTN *SaveStateSize ) { return EFI_UNSUPPORTED; diff --git a/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibSimpleFileSystem/UnitTestPersistenceLibSimpleFileSystem.c b/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibSimpleFileSystem/UnitTestPersistenceLibSimpleFileSystem.c index ed4a7d1615..d7a62145da 100644 --- a/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibSimpleFileSystem/UnitTestPersistenceLibSimpleFileSystem.c +++ b/UnitTestFrameworkPkg/Library/UnitTestPersistenceLibSimpleFileSystem/UnitTestPersistenceLibSimpleFileSystem.c @@ -4,6 +4,7 @@ version of the internal test state in case the test needs to quit and restore. Copyright (c) Microsoft Corporation.<BR> + Copyright (c) 2022, Intel Corporation. All rights reserved.<BR> SPDX-License-Identifier: BSD-2-Clause-Patent **/ @@ -16,6 +17,7 @@ #include <Library/DevicePathLib.h> #include <Library/ShellLib.h> #include <Protocol/LoadedImage.h> +#include <UnitTestFrameworkTypes.h> #define CACHE_FILE_SUFFIX L"_Cache.dat" @@ -213,6 +215,7 @@ DoesCacheExist ( @param[in] FrameworkHandle A pointer to the framework that is being persisted. @param[in] SaveData A pointer to the buffer containing the serialized framework internal state. + @param[in] SaveStateSize The size of SaveData in bytes. @retval EFI_SUCCESS Data is persisted and the test can be safely quit. @retval Others Data is not persisted and test cannot be resumed upon exit. @@ -222,7 +225,8 @@ EFI_STATUS EFIAPI SaveUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - IN UNIT_TEST_SAVE_HEADER *SaveData + IN VOID *SaveData, + IN UINTN SaveStateSize ) { EFI_DEVICE_PATH_PROTOCOL *FileDevicePath; @@ -280,7 +284,7 @@ SaveUnitTestCache ( // // Write the data to the file. // - WriteCount = SaveData->SaveStateSize; + WriteCount = SaveStateSize; DEBUG ((DEBUG_INFO, "%a - Writing %d bytes to file...\n", __FUNCTION__, WriteCount)); Status = ShellWriteFile ( FileHandle, @@ -288,7 +292,7 @@ SaveUnitTestCache ( SaveData ); - if (EFI_ERROR (Status) || (WriteCount != SaveData->SaveStateSize)) { + if (EFI_ERROR (Status) || (WriteCount != SaveStateSize)) { DEBUG ((DEBUG_ERROR, "%a - Writing to file failed! %r\n", __FUNCTION__, Status)); } else { DEBUG ((DEBUG_INFO, "%a - SUCCESS!\n", __FUNCTION__)); @@ -312,8 +316,9 @@ Exit: Will allocate a buffer to hold the loaded data. @param[in] FrameworkHandle A pointer to the framework that is being persisted. - @param[in] SaveData A pointer pointer that will be updated with the address + @param[out] SaveData A pointer pointer that will be updated with the address of the loaded data buffer. + @param[out] SaveStateSize Return the size of SaveData in bytes. @retval EFI_SUCCESS Data has been loaded successfully and SaveData is updated with a pointer to the buffer. @@ -325,7 +330,8 @@ EFI_STATUS EFIAPI LoadUnitTestCache ( IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle, - OUT UNIT_TEST_SAVE_HEADER **SaveData + OUT VOID **SaveData, + OUT UINTN *SaveStateSize ) { EFI_STATUS Status; @@ -334,7 +340,7 @@ LoadUnitTestCache ( BOOLEAN IsFileOpened; UINT64 LargeFileSize; UINTN FileSize; - UNIT_TEST_SAVE_HEADER *Buffer; + VOID *Buffer; IsFileOpened = FALSE; Buffer = NULL; @@ -380,8 +386,9 @@ LoadUnitTestCache ( // // Now that we know the size, let's allocated a buffer to hold the contents. // - FileSize = (UINTN)LargeFileSize; // You know what... if it's too large, this lib don't care. - Buffer = AllocatePool (FileSize); + FileSize = (UINTN)LargeFileSize; // You know what... if it's too large, this lib don't care. + *SaveStateSize = FileSize; + Buffer = AllocatePool (FileSize); if (Buffer == NULL) { DEBUG ((DEBUG_ERROR, "%a - Failed to allocate a pool to hold the file contents! %r\n", __FUNCTION__, Status)); Status = EFI_OUT_OF_RESOURCES; -- 2.31.1.windows.1 |
|
Re: [PATCH 3/3] .azurepipelines: Expand PlatformCI template for Shell UnitTest
duntan
Hi Michael,
toggle quoted message
Show quoted text
Thanks for the reply! In the following PR, I added an unit test list in the new OvmfPkg platform CI JOB. In PlatformCI_OvmfPkg_Ubuntu_GCC5_PR and PlatformCI_OvmfPkg_Windows_VS2019_PR, the CI for specific unit test list was triggered. https://github.com/tianocore/edk2/pull/3651 Thanks, Dun -----Original Message-----
From: Michael Kubacki <mikuback@...> Sent: Tuesday, December 6, 2022 9:24 AM To: devel@edk2.groups.io; Tan, Dun <dun.tan@...> Cc: Sean Brogan <sean.brogan@...>; Kinney, Michael D <michael.d.kinney@...>; Gao, Liming <gaoliming@...>; Ni, Ray <ray.ni@...> Subject: Re: [edk2-devel] [PATCH 3/3] .azurepipelines: Expand PlatformCI template for Shell UnitTest Sorry for the delay Dun. Can you please share an edk2 pull request with this change? Thanks, Michael On 12/4/2022 10:57 PM, duntan wrote: Hi all, |
|
Event: TianoCore Bug Triage - APAC / NAMO - Tuesday, December 6, 2022
#cal-reminder
Group Notification <noreply@...>
Reminder: TianoCore Bug Triage - APAC / NAMO When: Where: Organizer: Liming Gao gaoliming@... Description: TianoCore Bug Triage - APAC / NAMO Hosted by Liming Gao
________________________________________________________________________________ Microsoft Teams meeting Join on your computer or mobile app Click here to join the meeting Join with a video conferencing device Video Conference ID: 116 062 094 0 Alternate VTC dialing instructions Or call in (audio only) +1 916-245-6934,,77463821# United States, Sacramento Phone Conference ID: 774 638 21# |
|
Re: [PATCH 1/1] ShellPkg: Improve "ping" output by adding equals sign after time
Gao, Zhichao
Reviewed-by: Zhichao Gao <zhichao.gao@...>
toggle quoted message
Show quoted text
Thanks, Zhichao -----Original Message----- |
|
Re: [Patch 1/2] OvmfPkg: Change default to disable MptScsi and PvScsi
dann frazier
On Mon, Dec 5, 2022 at 6:25 PM Kinney, Michael D
<michael.d.kinney@...> wrote: Apparently - assuming I've correctly connected the dots: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1016359 |
|
Re: [Patch 1/1] UnitTestFrameworkPkg: Library classes private to public
Zhiguang Liu
Hi Mike,
toggle quoted message
Show quoted text
Yes, I will file a BZ and work out a patch serial, including current patch. Thanks Zhiguang -----Original Message----- |
|
Re: [Patch 1/2] OvmfPkg: Change default to disable MptScsi and PvScsi
Michael D Kinney
Hi Dann,
toggle quoted message
Show quoted text
The purpose of this first step was due to lack of support/maintainers/reviewers. If there are issues, then we need to find maintainers/reviewers starting with those that are using and depend on these features. If there are no issues from disabling these by default, then the 2nd step would be deleting the code and the flags. Are these features actually being used? Thanks, Mike -----Original Message----- |
|
Re: [PATCH 3/3] .azurepipelines: Expand PlatformCI template for Shell UnitTest
Michael Kubacki
Sorry for the delay Dun. Can you please share an edk2 pull request with this change?
toggle quoted message
Show quoted text
Thanks, Michael On 12/4/2022 10:57 PM, duntan wrote:
Hi all, |
|
Re: feature flag change notifications
Michael D Kinney
Hi Dann,
toggle quoted message
Show quoted text
These are reasonable requests. Adding Liming Gao who is currently responsible for the edk2 releases. Let's start with release notes and see if some of these can be added to the release documentation and add to the edk2 release process to clearly note these type of changes in future release notes. As far as #error and #warn. Those are possible, but we would need to do some analysis for the types of changes that would require that behavior. Your examples are useful as a starting point. Once concern is how many of those #error/#warn conditions will build up over time and then a process to remove them after an expiration period. Mike -----Original Message----- |
|
Re: [Patch V2 1/3] [edk2-staging]BaseTools: Add Python VfrCompiler tool
Bob Feng
This patch looks good. As we are WIP of convert C tool to Python tool, This patch can be merged to staging branch.
toggle quoted message
Show quoted text
Reviewed-by: Bob Feng <bob.c.feng@...> -----Original Message-----
From: Chen, Christine <yuwei.chen@...> Sent: Tuesday, November 15, 2022 4:46 PM To: devel@edk2.groups.io Cc: Yang, Yuting2 <yuting2.yang@...>; Feng, Bob C <bob.c.feng@...>; Gao, Liming <gaoliming@...> Subject: [Patch V2 1/3] [edk2-staging]BaseTools: Add Python VfrCompiler tool From: Yuting Yang <yuting2.yang@...> This is the python implementation of the C VfrCompiler tool. Currently, this python tool will generate yaml/json files for better variable related information presentation. In future, it will cover the same usage as the C tool. Cc: Bob Feng <bob.c.feng@...> Cc: Liming Gao <gaoliming@...> Cc: Yuwei Chen <yuwei.chen@...> Signed-off-by: Yuting Yang <yuting2.yang@...> --- BaseTools/Source/Python/VfrCompiler/CommonCtypes.py | 1394 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/README.md | 20 + BaseTools/Source/Python/VfrCompiler/VfrError.py | 162 ++++++++ BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py | 2738 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 | 1887 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py | 1709 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py | 20460 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py | 5106 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/VfrTree.py | 88 +++++ BaseTools/Source/Python/VfrCompiler/VfrUtility.py | 1991 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ BaseTools/Source/Python/VfrCompiler/main.py | 27 ++ 11 files changed, 35582 insertions(+) diff --git a/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py b/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py new file mode 100644 index 0000000000..731ae15609 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py @@ -0,0 +1,1394 @@ +from ctypes import * +from re import A, X +from telnetlib import X3PAD +from tkinter import YView +import uuid +from VfrCompiler.VfrError import * +from struct import * + +EFI_STRING_ID_INVALID = 0x0 +EFI_HII_DEFAULT_CLASS_STANDARD = 0x0000 +EFI_HII_DEFAULT_CLASS_MANUFACTURING = 0x0001 +EFI_IFR_MAX_LENGTH = 0xFF +EFI_VARSTORE_ID_INVALID = 0 +EFI_VARSTORE_ID_START = 0x20 +EFI_VAROFFSET_INVALID = 0xFFFF +EFI_IMAGE_ID_INVALID = 0xFFFF + +EFI_NON_DEVICE_CLASS = 0x00 +EFI_DISK_DEVICE_CLASS = 0x01 +EFI_VIDEO_DEVICE_CLASS = 0x02 +EFI_NETWORK_DEVICE_CLASS = 0x04 +EFI_INPUT_DEVICE_CLASS = 0x08 +EFI_ON_BOARD_DEVICE_CLASS = 0x10 +EFI_OTHER_DEVICE_CLASS = 0x20 + +EFI_SETUP_APPLICATION_SUBCLASS = 0x00 +EFI_GENERAL_APPLICATION_SUBCLASS = 0x01 +EFI_FRONT_PAGE_SUBCLASS = 0x02 +EFI_SINGLE_USE_SUBCLASS = 0x03 + +# EFI_HII_PACKAGE_TYPE_x. + +EFI_HII_PACKAGE_TYPE_ALL = 0x00 +EFI_HII_PACKAGE_TYPE_GUID = 0x01 +EFI_HII_PACKAGE_FORM = 0x02 +EFI_HII_PACKAGE_KEYBOARD_LAYOUT = 0x03 +EFI_HII_PACKAGE_STRINGS = 0x04 +EFI_HII_PACKAGE_FONTS = 0x05 +EFI_HII_PACKAGE_IMAGES = 0x06 +EFI_HII_PACKAGE_SIMPLE_FONTS = 0x07 +EFI_HII_PACKAGE_DEVICE_PATH = 0x08 +EFI_HII_PACKAGE_END = 0xDF +EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN = 0xE0 +EFI_HII_PACKAGE_TYPE_SYSTEM_END = 0xFF + +EFI_IFR_EXTEND_OP_LABEL = 0x0 +EFI_IFR_EXTEND_OP_BANNER = 0x1 +EFI_IFR_EXTEND_OP_TIMEOUT = 0x2 +EFI_IFR_EXTEND_OP_CLASS = 0x3 +EFI_IFR_EXTEND_OP_SUBCLASS = 0x4 + +MAX_IFR_EXPRESSION_DEPTH = 0x9 + +INVALID_ARRAY_INDEX = 0xFFFFFFFF + +EFI_IFR_TYPE_NUM_SIZE_8 = 0x00 +EFI_IFR_TYPE_NUM_SIZE_16 = 0x01 +EFI_IFR_TYPE_NUM_SIZE_32 = 0x02 +EFI_IFR_TYPE_NUM_SIZE_64 = 0x03 +EFI_IFR_TYPE_BOOLEAN = 0x04 +EFI_IFR_TYPE_TIME = 0x05 +EFI_IFR_TYPE_DATE = 0x06 +EFI_IFR_TYPE_STRING = 0x07 +EFI_IFR_TYPE_OTHER = 0x08 +EFI_IFR_TYPE_UNDEFINED = 0x09 +EFI_IFR_TYPE_ACTION = 0x0A +EFI_IFR_TYPE_BUFFER = 0x0B +EFI_IFR_TYPE_REF = 0x0C + + +EFI_IFR_FLAGS_HORIZONTAL = 0x01 + +EFI_IFR_FLAG_READ_ONLY = 0x01 +EFI_IFR_FLAG_CALLBACK = 0x04 +EFI_IFR_FLAG_RESET_REQUIRED = 0x10 +EFI_IFR_FLAG_REST_STYLE = 0x20 +EFI_IFR_FLAG_RECONNECT_REQUIRED = 0x40 +EFI_IFR_FLAG_OPTIONS_ONLY = 0x80 + +EFI_IFR_STRING_MULTI_LINE = 0x01 + +EDKII_IFR_DISPLAY_BIT = 0xC0 +EDKII_IFR_DISPLAY_INT_DEC_BIT = 0x00 +EDKII_IFR_DISPLAY_UINT_DEC_BIT = 0x40 +EDKII_IFR_DISPLAY_UINT_HEX_BIT = 0x80 + +EDKII_IFR_NUMERIC_SIZE_BIT = 0x3F + +EFI_IFR_MAX_DEFAULT_TYPE = 0x10 + + +class EFI_GUID(Structure): + _pack_ = 1 + _fields_ = [ + ('Data1', c_uint32), + ('Data2', c_uint16), + ('Data3', c_uint16), + ('Data4', c_ubyte * 8), + ] + + def from_list(self, listformat: list) -> None: + self.Data1 = listformat[0] + self.Data2 = listformat[1] + self.Data3 = listformat[2] + for i in range(8): + self.Data4[i] = listformat[i + 3] + + def __cmp__(self, otherguid) -> bool: + if not isinstance(otherguid, EFI_GUID): + return 'Input is not the GUID instance!' + rt = False + if self.Data1 == otherguid.Data1 and self.Data2 == otherguid.Data2 and self.Data3 == otherguid.Data3: + rt = True + for i in range(8): + rt = rt & (self.Data4[i] == otherguid.Data4[i]) + return rt + + +GuidArray = c_ubyte * 8 +EFI_HII_PLATFORM_SETUP_FORMSET_GUID = EFI_GUID( + 0x93039971, 0x8545, 0x4b04, + GuidArray(0xb4, 0x5e, 0x32, 0xeb, 0x83, 0x26, 0x4, 0xe)) + +EFI_IFR_TIANO_GUID = EFI_GUID( + 0xf0b1735, 0x87a0, 0x4193, + GuidArray(0xb2, 0x66, 0x53, 0x8c, 0x38, 0xaf, 0x48, 0xce)) + +EDKII_IFR_BIT_VARSTORE_GUID = (0x82DDD68B, 0x9163, 0x4187, + GuidArray(0x9B, 0x27, 0x20, 0xA8, 0xFD, 0x60, + 0xA7, 0x1D)) + +EFI_IFR_FRAMEWORK_GUID = (0x31ca5d1a, 0xd511, 0x4931, + GuidArray(0xb7, 0x82, 0xae, 0x6b, 0x2b, 0x17, 0x8c, + 0xd7)) + +class EFI_IFR_OP_HEADER(Structure): + _pack_ = 1 + _fields_ = [ + ('OpCode', c_ubyte), + ('Length', c_ubyte, 7), # + ('Scope', c_ubyte, 1), # + ] + + +class EFI_IFR_FORM_SET(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('FormSetTitle', c_uint16), + ('Help', c_uint16), + ('Flags', c_ubyte), + ] + + +class EFI_IFR_GUID_CLASS(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_ubyte), + ('Class', c_uint16), + ] + + +class EFI_IFR_GUID_SUBCLASS(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_ubyte), + ('SubClass', c_uint16), + ] + + +class EFI_IFR_DEFAULTSTORE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DefaultName', c_uint16), + ('DefaultId', c_uint16), + ] + + +class EFI_IFR_VARSTORE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('VarStoreId', c_uint16), + ('Size', c_uint16), + ('Name', c_wchar_p), + ] + + +class EFI_IFR_VARSTORE_EFI(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('VarStoreId', c_uint16), + ('Attributes', c_uint32), + ('Size', c_uint16), + ('Name', c_wchar_p), + ] + + +class EFI_IFR_GUID(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ] + + +class EFI_HII_PACKAGE_HEADER(Structure): + _pack_ = 1 + _fields_ = [ + ('Length', c_uint32, 24), + ('Type', c_uint32, 8), + ] + + +class EFI_HII_STRING_PACKAGE_HDR(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_HII_PACKAGE_HEADER), + ('HdrSize', c_uint32), + ('StringInfoOffset', c_uint32), + ('LanguageWindow', c_ushort * 16), + ('LanguageName', c_uint16), + ('Language', c_char * 2), + ] + + +class EFI_IFR_VARSTORE_NAME_VALUE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('VarStoreId', c_uint16), + ('Guid', EFI_GUID), + ] + + +class EFI_IFR_FORM(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('FormId', c_uint16), + ('FormTitle', c_uint16), + ] + + +class EFI_IFR_GUID_BANNER(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_ubyte), + ('Title', c_uint16), + ('LineNumber', c_uint16), + ('Alignment', c_ubyte), + ] + + +class EFI_IFR_GUID_TIMEOUT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_ubyte), + ('TimeOut', c_uint16), + ] + + +class EFI_IFR_GUID_LABEL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_ubyte), + ('Number', c_uint16), + ] + + +class EFI_IFR_RULE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('RuleId', c_ubyte), + ] + + +class EFI_IFR_STATEMENT_HEADER(Structure): + _pack_ = 1 + _fields_ = [ + ('Prompt', c_uint16), + ('Help', c_uint16), + ] + + +class EFI_IFR_SUBTITLE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Statement', EFI_IFR_STATEMENT_HEADER), + ('Flags', c_ubyte), + ] + + +class EFI_IFR_TEXT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Statement', EFI_IFR_STATEMENT_HEADER), + ('TextTwo', c_uint16), + ] + + +class EFI_IFR_IMAGE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Id', c_uint16), + ] + + +class VarStoreInfoNode(Union): + _pack_ = 1 + _fields_ = [ + ('VarName', c_uint16), + ('VarOffset', c_uint16), + ] + + +class EFI_IFR_QUESTION_HEADER(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_STATEMENT_HEADER), + ('QuestionId', c_uint16), + ('VarStoreId', c_uint16), + ('VarStoreInfo', VarStoreInfoNode), + ('Flags', c_ubyte), + ] + + +class u8Node(Structure): + _pack_ = 1 + _fields_ = [ + ('MinValue', c_ubyte), + ('MaxValue', c_ubyte), + ('Step', c_ubyte), + ] + + +class u16Node(Structure): + _pack_ = 1 + _fields_ = [ + ('MinValue', c_uint16), + ('MaxValue', c_uint16), + ('Step', c_uint16), + ] + + +class u32Node(Structure): + _pack_ = 1 + _fields_ = [ + ('MinValue', c_uint32), + ('MaxValue', c_uint32), + ('Step', c_uint32), + ] + + +class u64Node(Structure): + _pack_ = 1 + _fields_ = [ + ('MinValue', c_uint64), + ('MaxValue', c_uint64), + ('Step', c_uint64), + ] + + +class MINMAXSTEP_DATA(Union): + _pack_ = 1 + _fields_ = [ + ('u8', u8Node), + ('u16', u16Node), + ('u32', u32Node), + ('u64', u64Node), + ] + + +EFI_IFR_NUMERIC_SIZE = 0x03 +EFI_IFR_NUMERIC_SIZE_1 = 0x00 +EFI_IFR_NUMERIC_SIZE_2 = 0x01 +EFI_IFR_NUMERIC_SIZE_4 = 0x02 +EFI_IFR_NUMERIC_SIZE_8 = 0x03 + +EFI_IFR_DISPLAY = 0x30 +EFI_IFR_DISPLAY_INT_DEC = 0x00 +EFI_IFR_DISPLAY_UINT_DEC = 0x10 +EFI_IFR_DISPLAY_UINT_HEX = 0x20 + +class EFI_IFR_ONE_OF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('Flags', c_ubyte), + ('data', MINMAXSTEP_DATA), + ] + + +EFI_IFR_CHECKBOX_DEFAULT = 0x01 +EFI_IFR_CHECKBOX_DEFAULT_MFG = 0x02 + + +class EFI_IFR_CHECKBOX(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('Flags', c_ubyte), + ] + + +class EFI_IFR_NUMERIC(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('Flags', c_ubyte), + ('Data', MINMAXSTEP_DATA), + ] + + +class EFI_IFR_PASSWORD(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('MinSize', c_uint16), + ('MaxSize', c_uint16), + ] + + +class EFI_HII_TIME(Structure): + _pack_ = 1 + _fields_ = [ + ('Hour', c_ubyte), + ('Minute', c_ubyte), + ('Second', c_ubyte), + ] + + +class EFI_HII_DATE(Structure): + _pack_ = 1 + _fields_ = [ + ('Year', c_uint16), + ('Month', c_ubyte), + ('Day', c_ubyte), + ] + + +class EFI_HII_REF(Structure): + _pack_ = 1 + _fields_ = [ + ('QuestionId', c_uint16), + ('FormId', c_uint16), + ('FormSetGuid', EFI_GUID), + ('DevicePath', c_uint16), + ] + + +class EFI_IFR_TYPE_VALUE(Union): + _pack_ = 1 + _fields_ = [ + ('u8', c_ubyte), + ('u16', c_uint16), + ('u32', c_uint32), + ('u64', c_uint64), + ('b', c_bool), + ('time', EFI_HII_TIME), + ('date', EFI_HII_DATE), + ('string', c_uint16), + ('ref', EFI_HII_REF), + ] + + +class EFI_IFR_ONE_OF_OPTION(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Option', c_uint16), + ('Flags', c_ubyte), + ('Type', c_ubyte), + ('Value', EFI_IFR_TYPE_VALUE), + ] + +def Refine_EFI_IFR_ONE_OF_OPTION(Nums): + class EFI_IFR_ONE_OF_OPTION(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Option', c_uint16), + ('Flags', c_ubyte), + ('Type', c_ubyte), + ('Value', EFI_IFR_TYPE_VALUE * Nums), + ] + return EFI_IFR_ONE_OF_OPTION + + +EFI_IFR_OPTION_DEFAULT = 0x10 +EFI_IFR_OPTION_DEFAULT_MFG = 0x20 + + +class EFI_IFR_SUPPRESS_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_LOCKED(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ACTION(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('QuestionConfig', c_uint16), + ] + + +class EFI_IFR_REF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('FormId', c_uint16), + ] + + +class EFI_IFR_REF2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('FormId', c_uint16), + ('QuestionId', c_uint16), + ] + + +class EFI_IFR_REF3(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('FormId', c_uint16), + ('QuestionId', c_uint16), + ('FormSetId', EFI_GUID), + ] + + +class EFI_IFR_REF4(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('FormId', c_uint16), + ('QuestionId', c_uint16), + ('FormSetId', EFI_GUID), + ('DevicePath', c_uint16), + ] + + +class EFI_IFR_REF5(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ] + + +class EFI_IFR_RESET_BUTTON(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Statement', EFI_IFR_STATEMENT_HEADER), + ('DefaultId', c_uint16), + ] + + +class EFI_IFR_NO_SUBMIT_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Error', c_uint16), + ] + + +class EFI_IFR_INCONSISTENT_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Error', c_uint16), + ] + + +class EFI_IFR_EQ_ID_VAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('QuestionId', c_uint16), + ('Value', c_uint16), + ] + + +class EFI_IFR_EQ_ID_ID(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('QuestionId1', c_uint16), + ('QuestionId2', c_uint16), + ] + +class EFI_IFR_EQ_ID_VAL_LIST(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('QuestionId', c_uint16), + ('ListLength', c_uint16), + ('ValueList', c_uint16), # + ] + + +def Refine_EFI_IFR_EQ_ID_VAL_LIST(Nums): + class EFI_IFR_EQ_ID_VAL_LIST(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('QuestionId', c_uint16), + ('ListLength', c_uint16), + ('ValueList', c_uint16 * Nums), # + ] + return EFI_IFR_EQ_ID_VAL_LIST + + +class EFI_IFR_AND(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_OR(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_NOT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_GRAY_OUT_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_DATE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('Flags', c_ubyte), + ] + + +EFI_QF_DATE_YEAR_SUPPRESS = 0x01 +EFI_QF_DATE_MONTH_SUPPRESS = 0x02 +EFI_QF_DATE_DAY_SUPPRESS = 0x04 + +EFI_QF_DATE_STORAGE = 0x30 +QF_DATE_STORAGE_NORMAL = 0x00 +QF_DATE_STORAGE_TIME = 0x10 +QF_DATE_STORAGE_WAKEUP = 0x20 + + +class EFI_IFR_TIME(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('Flags', c_ubyte), + ] + + +QF_TIME_HOUR_SUPPRESS = 0x01 +QF_TIME_MINUTE_SUPPRESS = 0x02 +QF_TIME_SECOND_SUPPRESS = 0x04 +QF_TIME_STORAGE = 0x30 +QF_TIME_STORAGE_NORMAL = 0x00 +QF_TIME_STORAGE_TIME = 0x10 +QF_TIME_STORAGE_WAKEUP = 0x20 + + +class EFI_IFR_STRING(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('MinSize', c_ubyte), + ('MaxSize', c_ubyte), + ('Flags', c_ubyte), + ] + + +class EFI_IFR_REFRESH(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('RefreshInterval', c_ubyte), + ] + + +class EFI_IFR_DISABLE_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_TO_LOWER(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_TO_UPPER(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_MAP(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ORDERED_LIST(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Question', EFI_IFR_QUESTION_HEADER), + ('MaxContainers', c_ubyte), + ('Flags', c_ubyte), + ] + + +EFI_IFR_UNIQUE_SET = 0x01 +EFI_IFR_NO_EMPTY_SET = 0x02 + + +class EFI_IFR_VARSTORE_DEVICE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DevicePath', c_uint16), + ] + + +class EFI_IFR_VERSION(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_END(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_MATCH(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_GET(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('VarStoreId', c_uint16), + ('VarStoreInfo', VarStoreInfoNode), ########## + ('VarStoreType', c_ubyte), + ] + + +class EFI_IFR_SET(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('VarStoreId', c_uint16), + ('VarStoreInfo', VarStoreInfoNode), ########## + ('VarStoreType', c_ubyte), + ] + + +class EFI_IFR_READ(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_WRITE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_EQUAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_NOT_EQUAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_GREATER_THAN(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_GREATER_EQUAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_LESS_EQUAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_LESS_THAN(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_BITWISE_AND(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_BITWISE_OR(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_BITWISE_NOT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_SHIFT_LEFT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_SHIFT_RIGHT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ADD(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_SUBTRACT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_MULTIPLY(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_DIVIDE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_MODULO(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_RULE_REF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('RuleId', c_ubyte), + ] + + +class EFI_IFR_QUESTION_REF1(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('QuestionId', c_uint16), + ] + + +class EFI_IFR_QUESTION_REF2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_QUESTION_REF3(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_QUESTION_REF3_2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DevicePath', c_uint16), + ] + + +class EFI_IFR_QUESTION_REF3_3(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DevicePath', c_uint16), + ('Guid', EFI_GUID), + ] + + +class EFI_IFR_UINT8(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Value', c_ubyte), + ] + + +class EFI_IFR_UINT16(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Value', c_uint16), + ] + + +class EFI_IFR_UINT32(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Value', c_uint32), + ] + + +class EFI_IFR_UINT64(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Value', c_uint64), + ] + + +class EFI_IFR_TRUE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_FALSE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_TO_UINT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_TO_STRING(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Format', c_ubyte), + ] + + +class EFI_IFR_TO_BOOLEAN(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_MID(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_FIND(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Format', c_ubyte), + ] + + +class EFI_IFR_TOKEN(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_STRING_REF1(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('StringId', c_uint16), + ] + + +class EFI_IFR_STRING_REF2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_CONDITIONAL(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ZERO(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ONE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_ONES(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_UNDEFINED(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_LENGTH(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_DUP(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_THIS(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +EFI_IFR_FLAGS_FIRST_MATCHING = 0x00 +EFI_IFR_FLAGS_FIRST_NON_MATCHING = 0x01 + +class EFI_IFR_SPAN(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Flags', c_ubyte), + ] + + +class EFI_IFR_VALUE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_DEFAULT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DefaultId', c_uint16), + ('Type', c_ubyte), + ('Value', EFI_IFR_TYPE_VALUE), + ] + +def Refine_EFI_IFR_DEFAULT(Nums): + class EFI_IFR_DEFAULT(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DefaultId', c_uint16), + ('Type', c_ubyte), + ('Value', EFI_IFR_TYPE_VALUE * Nums), + ] + return EFI_IFR_DEFAULT + + +class EFI_IFR_DEFAULT_2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('DefaultId', c_uint16), + ('Type', c_ubyte), + ] + +class EFI_IFR_FORM_MAP(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('FormId', c_uint16), + ] + +class EFI_IFR_FORM_MAP_METHOD(Structure): + _pack_ = 1 + _fields_ = [ + ('MethodTitle', c_uint16), + ('MethodIdentifier', EFI_GUID), + ] + +class EFI_IFR_CATENATE(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_SECURITY(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Permissions', EFI_GUID), + ] + + +class EFI_IFR_MODAL_TAG(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ] + + +class EFI_IFR_REFRESH_ID(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('RefreshEventGroupId', EFI_GUID), + ] + + +class EFI_IFR_WARNING_IF(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Warning', c_uint16), + ('TimeOut', c_ubyte), + ] + + +class EFI_IFR_MATCH2(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('SyntaxType', EFI_GUID), + ] + + +EFI_IFR_FORM_OP = 0x01 +EFI_IFR_SUBTITLE_OP = 0x02 +EFI_IFR_TEXT_OP = 0x03 +EFI_IFR_IMAGE_OP = 0x04 +EFI_IFR_ONE_OF_OP = 0x05 +EFI_IFR_CHECKBOX_OP = 0x06 +EFI_IFR_NUMERIC_OP = 0x07 +EFI_IFR_PASSWORD_OP = 0x08 +EFI_IFR_ONE_OF_OPTION_OP = 0x09 +EFI_IFR_SUPPRESS_IF_OP = 0x0A +EFI_IFR_LOCKED_OP = 0x0B +EFI_IFR_ACTION_OP = 0x0C +EFI_IFR_RESET_BUTTON_OP = 0x0D +EFI_IFR_FORM_SET_OP = 0x0E +EFI_IFR_REF_OP = 0x0F +EFI_IFR_NO_SUBMIT_IF_OP = 0x10 +EFI_IFR_INCONSISTENT_IF_OP = 0x11 +EFI_IFR_EQ_ID_VAL_OP = 0x12 +EFI_IFR_EQ_ID_ID_OP = 0x13 +EFI_IFR_EQ_ID_VAL_LIST_OP = 0x14 +EFI_IFR_AND_OP = 0x15 +EFI_IFR_OR_OP = 0x16 +EFI_IFR_NOT_OP = 0x17 +EFI_IFR_RULE_OP = 0x18 +EFI_IFR_GRAY_OUT_IF_OP = 0x19 +EFI_IFR_DATE_OP = 0x1A +EFI_IFR_TIME_OP = 0x1B +EFI_IFR_STRING_OP = 0x1C +EFI_IFR_REFRESH_OP = 0x1D +EFI_IFR_DISABLE_IF_OP = 0x1E +EFI_IFR_TO_LOWER_OP = 0x20 +EFI_IFR_TO_UPPER_OP = 0x21 +EFI_IFR_MAP_OP = 0x22 +EFI_IFR_ORDERED_LIST_OP = 0x23 +EFI_IFR_VARSTORE_OP = 0x24 +EFI_IFR_VARSTORE_NAME_VALUE_OP = 0x25 +EFI_IFR_VARSTORE_EFI_OP = 0x26 +EFI_IFR_VARSTORE_DEVICE_OP = 0x27 +EFI_IFR_VERSION_OP = 0x28 +EFI_IFR_END_OP = 0x29 +EFI_IFR_MATCH_OP = 0x2A +EFI_IFR_GET_OP = 0x2B +EFI_IFR_SET_OP = 0x2C +EFI_IFR_READ_OP = 0x2D +EFI_IFR_WRITE_OP = 0x2E +EFI_IFR_EQUAL_OP = 0x2F +EFI_IFR_NOT_EQUAL_OP = 0x30 +EFI_IFR_GREATER_THAN_OP = 0x31 +EFI_IFR_GREATER_EQUAL_OP = 0x32 +EFI_IFR_LESS_THAN_OP = 0x33 +EFI_IFR_LESS_EQUAL_OP = 0x34 +EFI_IFR_BITWISE_AND_OP = 0x35 +EFI_IFR_BITWISE_OR_OP = 0x36 +EFI_IFR_BITWISE_NOT_OP = 0x37 +EFI_IFR_SHIFT_LEFT_OP = 0x38 +EFI_IFR_SHIFT_RIGHT_OP = 0x39 +EFI_IFR_ADD_OP = 0x3A +EFI_IFR_SUBTRACT_OP = 0x3B +EFI_IFR_MULTIPLY_OP = 0x3C +EFI_IFR_DIVIDE_OP = 0x3D +EFI_IFR_MODULO_OP = 0x3E +EFI_IFR_RULE_REF_OP = 0x3F +EFI_IFR_QUESTION_REF1_OP = 0x40 +EFI_IFR_QUESTION_REF2_OP = 0x41 +EFI_IFR_UINT8_OP = 0x42 +EFI_IFR_UINT16_OP = 0x43 +EFI_IFR_UINT32_OP = 0x44 +EFI_IFR_UINT64_OP = 0x45 +EFI_IFR_TRUE_OP = 0x46 +EFI_IFR_FALSE_OP = 0x47 +EFI_IFR_TO_UINT_OP = 0x48 +EFI_IFR_TO_STRING_OP = 0x49 +EFI_IFR_TO_BOOLEAN_OP = 0x4A +EFI_IFR_MID_OP = 0x4B +EFI_IFR_FIND_OP = 0x4C +EFI_IFR_TOKEN_OP = 0x4D +EFI_IFR_STRING_REF1_OP = 0x4E +EFI_IFR_STRING_REF2_OP = 0x4F +EFI_IFR_CONDITIONAL_OP = 0x50 +EFI_IFR_QUESTION_REF3_OP = 0x51 +EFI_IFR_ZERO_OP = 0x52 +EFI_IFR_ONE_OP = 0x53 +EFI_IFR_ONES_OP = 0x54 +EFI_IFR_UNDEFINED_OP = 0x55 +EFI_IFR_LENGTH_OP = 0x56 +EFI_IFR_DUP_OP = 0x57 +EFI_IFR_THIS_OP = 0x58 +EFI_IFR_SPAN_OP = 0x59 +EFI_IFR_VALUE_OP = 0x5A +EFI_IFR_DEFAULT_OP = 0x5B +EFI_IFR_DEFAULTSTORE_OP = 0x5C +EFI_IFR_FORM_MAP_OP = 0x5D +EFI_IFR_CATENATE_OP = 0x5E +EFI_IFR_GUID_OP = 0x5F +EFI_IFR_SECURITY_OP = 0x60 +EFI_IFR_MODAL_TAG_OP = 0x61 +EFI_IFR_REFRESH_ID_OP = 0x62 +EFI_IFR_WARNING_IF_OP = 0x63 +EFI_IFR_MATCH2_OP = 0x64 + +ConditionOps = [EFI_IFR_NO_SUBMIT_IF_OP, EFI_IFR_DISABLE_IF_OP, EFI_IFR_SUPPRESS_IF_OP, EFI_IFR_GRAY_OUT_IF_OP, EFI_IFR_INCONSISTENT_IF_OP] +BasicDataTypes = ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'EFI_HII_DATE', 'EFI_HII_TIME', 'EFI_HII_REF'] + +class EFI_IFR_GUID_OPTIONKEY(Structure): + _pack_ = 1 + _fields_ = [ + ('Header', EFI_IFR_OP_HEADER), + ('Guid', EFI_GUID), + ('ExtendOpCode', c_uint8), + ('QuestionId', c_uint16), + ('OptionValue', EFI_IFR_TYPE_VALUE), + ('KeyValue', c_uint16), + ] + + +EFI_IFR_EXTEND_OP_OPTIONKEY = 0x0 +EFI_IFR_EXTEND_OP_VAREQNAME = 0x1 + +class EFI_COMPARE_TYPE(Enum): + EQUAL = 0 + LESS_EQUAL = 1 + LESS_THAN = 2 + GREATER_THAN = 3 + GREATER_EQUAL = 4 \ No newline at end of file diff --git a/BaseTools/Source/Python/VfrCompiler/README.md b/BaseTools/Source/Python/VfrCompiler/README.md new file mode 100644 index 0000000000..cf600581c9 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/README.md @@ -0,0 +1,20 @@ +# Python VfrCompiler Tool +## Overview +This python VfrCompiler tool is the implementation of the edk2 VfrCompiler tool which locates at https://github.com/tianocore/edk2/tree/master/BaseTools/Source/C/VfrCompile. + +### Introduction +The core function of the original C VfrCompiler tool is to convert the vfr file into IFR binary array. However, the vfr format file syntax is relatively uncommon and has poor readability for users. What's more, the C tool does not collect and store extra information except for binary generation. When any modification is needed, developers have to read and deal with the IFR binary, which is quite inefficient. To solve this issue, this python VfrCompiler tool proposes to generate the yaml format file on the basis of the vfr format file. With the yaml file, the layout and hierarchy of all Opcodes in the vfr file will be saved. Then modification will be much eaiser. In addition, an extra json file will be generated for better variable related information presentation. So the long-term aim of this tool is to cover the same usage as the edk2 C VfrCompiler and extend the yaml/json output for better readability and variability. + +### Main update in this commitment +- Update the vfr parser generator from ANTLR to ANTLR v4, which is more readable and is eaiser to add on new functions. +- Generate a yaml file for each vfr file. The yaml file displays all the contents in the Vfr file by different Opcode types in sequence. +- Generate a json file for each vfr file. The json file contains all the default values for different Opcode types in vfr files. + +### Known issues + +- The python VfrCompiler tool aims to cover the same usage as the edk2 C VfrCompiler. But currently, the python VfrCompiler tool does not support IFR binary generation feature, this feature will be added in future update. +- The python VfrCompiler tool will extend new functions, which is able to compile both the vfr and yaml files. This feature will be added in future update. + +### Use with Build System +- To use the VfrCompiler Python Tool with Build System, please add the ***'--vfr-yaml-enable'*** option in the build command. +- For Example: ***build -p OvmfPkg\OvmfPkgIa32X64.dsc -a IA32 -a X64 -j build.log --vfr-yaml-enable*** \ No newline at end of file diff --git a/BaseTools/Source/Python/VfrCompiler/VfrError.py b/BaseTools/Source/Python/VfrCompiler/VfrError.py new file mode 100644 index 0000000000..53b960b4e1 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/VfrError.py @@ -0,0 +1,162 @@ +import imp +import sys +import os +from enum import Enum +from Common.BuildToolError import * +import Common.EdkLogger as EdkLogger + + +class VfrReturnCode(Enum): + VFR_RETURN_SUCCESS = 0 + VFR_RETURN_ERROR_SKIPED = 1 + VFR_RETURN_FATAL_ERROR = 2 + VFR_RETURN_MISMATCHED = 3 + VFR_RETURN_INVALID_PARAMETER = 4 + VFR_RETURN_OUT_FOR_RESOURCES = 5 + VFR_RETURN_UNSUPPORTED = 6 + VFR_RETURN_REDEFINED = 7 + VFR_RETURN_FORMID_REDEFINED = 8 + VFR_RETURN_QUESTIONID_REDEFINED = 9 + VFR_RETURN_VARSTOREID_REDEFINED = 10 + VFR_RETURN_UNDEFINED = 11 + VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION = 12 + VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR = 13 + VFR_RETURN_GET_EFIVARSTORE_ERROR = 14 + VFR_RETURN_EFIVARSTORE_USE_ERROR = 15 + VFR_RETURN_EFIVARSTORE_SIZE_ERROR = 16 + VFR_RETURN_GET_NVVARSTORE_ERROR = 17 + VFR_RETURN_QVAR_REUSE = 18 + VFR_RETURN_FLAGS_UNSUPPORTED = 19 + VFR_RETURN_ERROR_ARRARY_NUM = 20 + VFR_RETURN_DATA_STRING_ERROR = 21 + VFR_RETURN_DEFAULT_VALUE_REDEFINED = 22 + VFR_RETURN_CONSTANT_ONLY = 23 + VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR = 24 + VFR_RETURN_BIT_WIDTH_ERROR = 25 + VFR_RETURN_STRING_TO_UINT_OVERFLOW = 26 + VFR_RETURN_CODEUNDEFINED = 27 + + +vfrErrorMessage = { + VfrReturnCode.VFR_RETURN_SUCCESS: '', + VfrReturnCode.VFR_RETURN_ERROR_SKIPED: '', + VfrReturnCode.VFR_RETURN_FATAL_ERROR: 'fatal error!!', + VfrReturnCode.VFR_RETURN_MISMATCHED: 'unexpected token', + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER: 'invalid parameter', + VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES: 'system out of memory', + VfrReturnCode.VFR_RETURN_UNSUPPORTED: 'unsupported', + VfrReturnCode.VFR_RETURN_REDEFINED: 'already defined', + VfrReturnCode.VFR_RETURN_FORMID_REDEFINED: 'form id already defined', + VfrReturnCode.VFR_RETURN_QUESTIONID_REDEFINED: + 'question id already defined', + VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED: + 'varstore id already defined', + VfrReturnCode.VFR_RETURN_UNDEFINED: 'undefined', + VfrReturnCode.VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION: + 'some variable has not defined by a question', + VfrReturnCode.VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR: + 'Data Structure is defined by more than one varstores: it can\'t be referred as varstore: only varstore name could be used.', + VfrReturnCode.VFR_RETURN_GET_EFIVARSTORE_ERROR: 'get efi varstore error', + VfrReturnCode.VFR_RETURN_EFIVARSTORE_USE_ERROR: + 'can not use the efi varstore like this', + VfrReturnCode.VFR_RETURN_EFIVARSTORE_SIZE_ERROR: + 'unsupport efi varstore size should be <= 8 bytes', + VfrReturnCode.VFR_RETURN_GET_NVVARSTORE_ERROR: + 'get name value varstore error', + VfrReturnCode.VFR_RETURN_QVAR_REUSE: + 'variable reused by more than one question', + VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED: 'flags unsupported', + VfrReturnCode.VFR_RETURN_ERROR_ARRARY_NUM: + 'array number error: the valid value is in (0 ~ MAX_INDEX-1 for UEFI vfr and in (1 ~ MAX_INDEX for Framework Vfr', + VfrReturnCode.VFR_RETURN_DATA_STRING_ERROR: + 'data field string error or not support', + VfrReturnCode.VFR_RETURN_DEFAULT_VALUE_REDEFINED: + 'default value re-defined with different value', + VfrReturnCode.VFR_RETURN_CONSTANT_ONLY: + 'only constant is allowed in the expression', + VfrReturnCode.VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR: + 'Varstore name is defined by more than one varstores: it can\'t be referred as varstore: only varstore structure name could be used.', + VfrReturnCode.VFR_RETURN_BIT_WIDTH_ERROR: + 'bit width must be <= sizeof (type * 8 and the max width can not > 32', + VfrReturnCode.VFR_RETURN_STRING_TO_UINT_OVERFLOW: + 'String to UINT* Overflow', + VfrReturnCode.VFR_RETURN_CODEUNDEFINED: 'undefined Error Code' +} + + +class EFI_VFR_WARNING_CODE(Enum): + VFR_WARNING_DEFAULT_VALUE_REDEFINED = 0 + VFR_WARNING_ACTION_WITH_TEXT_TWO = 1 + VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE = 2 + VFR_WARNING_CODEUNDEFINED = 3 + + +vfrWarningMessage = { + EFI_VFR_WARNING_CODE.VFR_WARNING_DEFAULT_VALUE_REDEFINED: + ": default value re-defined with different value", + EFI_VFR_WARNING_CODE.VFR_WARNING_ACTION_WITH_TEXT_TWO: + ": Action opcode should not have TextTwo part", + EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE: + ": Not recommend to use obsoleted framework opcode", + EFI_VFR_WARNING_CODE.VFR_WARNING_CODEUNDEFINED: ": undefined Warning Code" +} + + +class CVfrErrorHandle(): + + def __init__(self): + self.__InputFileName = None + self.__vfrErrorMessage = vfrErrorMessage + self.__vfrWarningMessage = vfrWarningMessage + self.__WarningAsError = False + + def SetWarningAsError(self, WarningAsError): + self.__WarningAsError = WarningAsError + + def SetInputFile(self, InputFile): + self.__InputFileName = InputFile + + def HandleWarning(self, WarningCode, LineNum, TokenValue=None): + if self.__vfrWarningMessage == None: + return 1 + WarningMsg = '' + for key in self.__vfrWarningMessage.keys(): + if WarningCode == self.__vfrWarningMessage[key]: + WarningMsg = self.__vfrWarningMessage[key] + break + if WarningMsg != '': + if self.__WarningAsError: + EdkLogger.error('VfrCompiler', WarningCode, WarningMsg, + self.__InputFileName, LineNum, + "warning treated as error") + EdkLogger.warn('VfrCompiler', WarningMsg, self.__InputFileName, + LineNum, TokenValue) + + def PrintMsg(self, + LineNum, + MsgType='Error', + ErrorMsg=None, + TokenValue=None): + if MsgType == 'Warning': + EdkLogger.verbose(ErrorMsg) + else: + EdkLogger.error('VfrCompiler', 0x3000, ErrorMsg, + self.__InputFileName, LineNum, TokenValue) + + def HandleError(self, ErrorCode, LineNum=None, TokenValue=None): + if self.__vfrErrorMessage == None: + return 1 + ErrorMsg = '' + for key in self.__vfrErrorMessage.keys(): + if ErrorCode == self.__vfrErrorMessage[key]: + ErrorMsg = self.__vfrErrorMessage[key] + break + if ErrorMsg != '': + EdkLogger.error('VfrCompiler', ErrorCode, ErrorMsg, + self.__InputFileName, LineNum, TokenValue) + return 1 + else: + return 0 + + +gCVfrErrorHandle = CVfrErrorHandle() \ No newline at end of file diff --git a/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py b/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py new file mode 100644 index 0000000000..efa8129d90 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py @@ -0,0 +1,2738 @@ +from ast import For +from re import L +from sre_parse import FLAGS +from stat import FILE_ATTRIBUTE_SPARSE_FILE +from VfrCompiler.CommonCtypes import * +from VfrCompiler.VfrError import VfrReturnCode +from VfrCompiler.VfrUtility import * + +from ctypes import * + + +class OpcodeSizesScopeNode(): + + def __init__(self, Size, Scope): + self.Size = Size + self.Scope = Scope + + +gOpcodeSizesScopeTable = [ + OpcodeSizesScopeNode(0, 0), # EFI_IFR_INVALID - 0x00 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM), 1), # EFI_IFR_FORM_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUBTITLE), + 1), # EFI_IFR_SUBTITLE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TEXT), 0), # EFI_IFR_TEXT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_IMAGE), 0), # EFI_IFR_IMAGE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE_OF), + 1), # EFI_IFR_ONE_OF_OP - 0x05 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CHECKBOX), + 1), # EFI_IFR_CHECKBOX_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NUMERIC), + 1), # EFI_IFR_NUMERIC_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_PASSWORD), + 1), # EFI_IFR_PASSWORD_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE_OF_OPTION), + 0), # EFI_IFR_ONE_OF_OPTION_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUPPRESS_IF), + 1), # EFI_IFR_SUPPRESS_IF - 0x0A + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LOCKED), + 0), # EFI_IFR_LOCKED_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ACTION), + 1), # EFI_IFR_ACTION_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RESET_BUTTON), + 1), # EFI_IFR_RESET_BUTTON_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM_SET), + 1), # EFI_IFR_FORM_SET_OP -0xE + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REF), 0), # EFI_IFR_REF_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NO_SUBMIT_IF), + 1), # EFI_IFR_NO_SUBMIT_IF_OP -0x10 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_INCONSISTENT_IF), + 1), # EFI_IFR_INCONSISTENT_IF_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL), + 0), # EFI_IFR_EQ_ID_VAL_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_ID), + 0), # EFI_IFR_EQ_ID_ID_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL_LIST), + 0), # EFI_IFR_EQ_ID_LIST_OP - 0x14 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_AND), 0), # EFI_IFR_AND_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_OR), 0), # EFI_IFR_OR_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NOT), 0), # EFI_IFR_NOT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RULE), 1), # EFI_IFR_RULE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GRAY_OUT_IF), + 1), # EFI_IFR_GRAYOUT_IF_OP - 0x19 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DATE), 1), # EFI_IFR_DATE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TIME), 1), # EFI_IFR_TIME_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING), + 1), # EFI_IFR_STRING_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REFRESH), + 0), # EFI_IFR_REFRESH_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DISABLE_IF), + 1), # EFI_IFR_DISABLE_IF_OP - 0x1E + OpcodeSizesScopeNode(0, 0), # 0x1F + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_LOWER), + 0), # EFI_IFR_TO_LOWER_OP - 0x20 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_UPPER), + 0), # EFI_IFR_TO_UPPER_OP - 0x21 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MAP), 1), # EFI_IFR_MAP - 0x22 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ORDERED_LIST), + 1), # EFI_IFR_ORDERED_LIST_OP - 0x23 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE), + 0), # EFI_IFR_VARSTORE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_NAME_VALUE), + 0), # EFI_IFR_VARSTORE_NAME_VALUE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_EFI), + 0), # EFI_IFR_VARSTORE_EFI_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_DEVICE), + 1), # EFI_IFR_VARSTORE_DEVICE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VERSION), + 0), # EFI_IFR_VERSION_OP - 0x28 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_END), 0), # EFI_IFR_END_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MATCH), + 0), # EFI_IFR_MATCH_OP - 0x2A + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GET), 0), # EFI_IFR_GET - 0x2B + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SET), 0), # EFI_IFR_SET - 0x2C + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_READ), + 0), # EFI_IFR_READ - 0x2D + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_WRITE), + 0), # EFI_IFR_WRITE - 0x2E + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQUAL), + 0), # EFI_IFR_EQUAL_OP - 0x2F + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NOT_EQUAL), + 0), # EFI_IFR_NOT_EQUAL_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GREATER_THAN), + 0), # EFI_IFR_GREATER_THAN_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GREATER_EQUAL), + 0), # EFI_IFR_GREATER_EQUAL_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LESS_THAN), + 0), # EFI_IFR_LESS_THAN_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LESS_EQUAL), + 0), # EFI_IFR_LESS_EQUAL_OP - 0x34 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_AND), + 0), # EFI_IFR_BITWISE_AND_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_OR), + 0), # EFI_IFR_BITWISE_OR_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_NOT), + 0), # EFI_IFR_BITWISE_NOT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SHIFT_LEFT), + 0), # EFI_IFR_SHIFT_LEFT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SHIFT_RIGHT), + 0), # EFI_IFR_SHIFT_RIGHT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ADD), + 0), # EFI_IFR_ADD_OP - 0x3A + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUBTRACT), + 0), # EFI_IFR_SUBTRACT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MULTIPLY), + 0), # EFI_IFR_MULTIPLY_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DIVIDE), + 0), # EFI_IFR_DIVIDE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MODULO), + 0), # EFI_IFR_MODULO_OP - 0x3E + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RULE_REF), + 0), # EFI_IFR_RULE_REF_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF1), + 0), # EFI_IFR_QUESTION_REF1_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF2), + 0), # EFI_IFR_QUESTION_REF2_OP - 0x41 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT8), 0), # EFI_IFR_UINT8 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT16), 0), # EFI_IFR_UINT16 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT32), 0), # EFI_IFR_UINT32 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT64), 0), # EFI_IFR_UTNT64 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TRUE), + 0), # EFI_IFR_TRUE_OP - 0x46 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FALSE), 0), # EFI_IFR_FALSE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_UINT), + 0), # EFI_IFR_TO_UINT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_STRING), + 0), # EFI_IFR_TO_STRING_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_BOOLEAN), + 0), # EFI_IFR_TO_BOOLEAN_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MID), 0), # EFI_IFR_MID_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FIND), 0), # EFI_IFR_FIND_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TOKEN), 0), # EFI_IFR_TOKEN_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING_REF1), + 0), # EFI_IFR_STRING_REF1_OP - 0x4E + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING_REF2), + 0), # EFI_IFR_STRING_REF2_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CONDITIONAL), + 0), # EFI_IFR_CONDITIONAL_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF3), + 0), # EFI_IFR_QUESTION_REF3_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ZERO), 0), # EFI_IFR_ZERO_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE), 0), # EFI_IFR_ONE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONES), 0), # EFI_IFR_ONES_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UNDEFINED), + 0), # EFI_IFR_UNDEFINED_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LENGTH), + 0), # EFI_IFR_LENGTH_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DUP), + 0), # EFI_IFR_DUP_OP - 0x57 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_THIS), 0), # EFI_IFR_THIS_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SPAN), 0), # EFI_IFR_SPAN_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VALUE), 1), # EFI_IFR_VALUE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DEFAULT), + 0), # EFI_IFR_DEFAULT_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DEFAULTSTORE), + 0), # EFI_IFR_DEFAULTSTORE_OP - 0x5C + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM_MAP), + 1), # EFI_IFR_FORM_MAP_OP - 0x5D + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CATENATE), + 0), # EFI_IFR_CATENATE_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GUID), 0), # EFI_IFR_GUID_OP + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SECURITY), + 0), # EFI_IFR_SECURITY_OP - 0x60 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MODAL_TAG), + 0), # EFI_IFR_MODAL_TAG_OP - 0x61 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REFRESH_ID), + 0), # EFI_IFR_REFRESH_ID_OP - 0x62 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_WARNING_IF), + 1), # EFI_IFR_WARNING_IF_OP - 0x63 + OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MATCH2), 0) +] + + +class SBufferNode(): + + def __init__(self, Buffer='', Next=None): + self.Buffer = Buffer + self.Next = Next + + +class CFormPkg(): + + def __init__(self, BufferSize=4096): + + Node = SBufferNode() + self.__BufferNodeQueueHead = Node + self.__BufferNodeQueueTail = Node + self.__CurrBufferNode = Node + self.__ReadBufferNode = None + self.__ReadBufferOffset = 0 + self.__PkgLength = 0 + self.__PendingAssignList = None + self.__BufferSize = BufferSize + + def GetPkgLength(self): + return self.__PkgLength + + def __createNewNode(self): + Node = SBufferNode() + return Node + + def __GetNodeBefore(self, CurrentNode): + FirstNode = self.__BufferNodeQueueHead + LastNode = self.__BufferNodeQueueHead + while FirstNode != None: + if FirstNode == CurrentNode: + break + + LastNode = FirstNode + FirstNode = FirstNode.Next + + if FirstNode == None: + LastNode = None + + return LastNode + + def __InsertNodeBefore(self, CurrentNode, NewNode): + LastNode = self.__GetNodeBefore(CurrentNode) + if LastNode == None: + return VfrReturnCode.VFR_RETURN_MISMATCHED + + NewNode.Next = LastNode.Next + LastNode.Next = NewNode + + def IfrBinBufferGet(self, Len): + if Len == 0 or Len > self.__BufferSize: + return None + if len(self.__CurrBufferNode.Buffer) + Len > self.__BufferSize: + Node = self.__createNewNode() + if Node == None: + return None + + if self.__BufferNodeQueueTail == None: + self.__BufferNodeQueueHead = self.__BufferNodeQueueTail = Node + else: + self.__BufferNodeQueueTail.Next = Node + mBufferNodeQueueTail = Node + self.__CurrBufferNode = Node + + self.__PkgLength += Len + + return self.__CurrBufferNode.Buffer + + + +gCFormPkg = CFormPkg() +gCreateOp = True + +gIfrObjPrintDebugTable = [ + "EFI_IFR_INVALID", + "EFI_IFR_FORM", + "EFI_IFR_SUBTITLE", + "EFI_IFR_TEXT", + "EFI_IFR_IMAGE", + "EFI_IFR_ONE_OF", + "EFI_IFR_CHECKBOX", + "EFI_IFR_NUMERIC", + "EFI_IFR_PASSWORD", + "EFI_IFR_ONE_OF_OPTION", + "EFI_IFR_SUPPRESS_IF", + "EFI_IFR_LOCKED", + "EFI_IFR_ACTION", + "EFI_IFR_RESET_BUTTON", + "EFI_IFR_FORM_SET", + "EFI_IFR_REF", + "EFI_IFR_NO_SUBMIT_IF", + "EFI_IFR_INCONSISTENT_IF", + "EFI_IFR_EQ_ID_VAL", + "EFI_IFR_EQ_ID_ID", + "EFI_IFR_EQ_ID_LIST", + "EFI_IFR_AND", + "EFI_IFR_OR", + "EFI_IFR_NOT", + "EFI_IFR_RULE", + "EFI_IFR_GRAY_OUT_IF", + "EFI_IFR_DATE", + "EFI_IFR_TIME", + "EFI_IFR_STRING", + "EFI_IFR_REFRESH", + "EFI_IFR_DISABLE_IF", + "EFI_IFR_INVALID", + "EFI_IFR_TO_LOWER", + "EFI_IFR_TO_UPPER", + "EFI_IFR_MAP", + "EFI_IFR_ORDERED_LIST", + "EFI_IFR_VARSTORE", + "EFI_IFR_VARSTORE_NAME_VALUE", + "EFI_IFR_VARSTORE_EFI", + "EFI_IFR_VARSTORE_DEVICE", + "EFI_IFR_VERSION", + "EFI_IFR_END", + "EFI_IFR_MATCH", + "EFI_IFR_GET", + "EFI_IFR_SET", + "EFI_IFR_READ", + "EFI_IFR_WRITE", + "EFI_IFR_EQUAL", + "EFI_IFR_NOT_EQUAL", + "EFI_IFR_GREATER_THAN", + "EFI_IFR_GREATER_EQUAL", + "EFI_IFR_LESS_THAN", + "EFI_IFR_LESS_EQUAL", + "EFI_IFR_BITWISE_AND", + "EFI_IFR_BITWISE_OR", + "EFI_IFR_BITWISE_NOT", + "EFI_IFR_SHIFT_LEFT", + "EFI_IFR_SHIFT_RIGHT", + "EFI_IFR_ADD", + "EFI_IFR_SUBTRACT", + "EFI_IFR_MULTIPLY", + "EFI_IFR_DIVIDE", + "EFI_IFR_MODULO", + "EFI_IFR_RULE_REF", + "EFI_IFR_QUESTION_REF1", + "EFI_IFR_QUESTION_REF2", + "EFI_IFR_UINT8", + "EFI_IFR_UINT16", + "EFI_IFR_UINT32", + "EFI_IFR_UINT64", + "EFI_IFR_TRUE", + "EFI_IFR_FALSE", + "EFI_IFR_TO_UINT", + "EFI_IFR_TO_STRING", + "EFI_IFR_TO_BOOLEAN", + "EFI_IFR_MID", + "EFI_IFR_FIND", + "EFI_IFR_TOKEN", + "EFI_IFR_STRING_REF1", + "EFI_IFR_STRING_REF2", + "EFI_IFR_CONDITIONAL", + "EFI_IFR_QUESTION_REF3", + "EFI_IFR_ZERO", + "EFI_IFR_ONE", + "EFI_IFR_ONES", + "EFI_IFR_UNDEFINED", + "EFI_IFR_LENGTH", + "EFI_IFR_DUP", + "EFI_IFR_THIS", + "EFI_IFR_SPAN", + "EFI_IFR_VALUE", + "EFI_IFR_DEFAULT", + "EFI_IFR_DEFAULTSTORE", + "EFI_IFR_FORM_MAP", + "EFI_IFR_CATENATE", + "EFI_IFR_GUID", + "EFI_IFR_SECURITY", + "EFI_IFR_MODAL_TAG", + "EFI_IFR_REFRESH_ID", + "EFI_IFR_WARNING_IF", + "EFI_IFR_MATCH2", +] + + +class CIfrObj(): + + def __init__(self, Obj=None, OpCode=None, ObjBinLen=0, DelayEmit=False, LineNo=0): + + self.__DelayEmit = DelayEmit + self.__PkgOffset = gCFormPkg.GetPkgLength() + self.__ObjBinLen = gOpcodeSizesScopeTable[ + OpCode].Size if ObjBinLen == 0 else ObjBinLen + + self.__ObjBinBuf = Obj + self.__LineNo = LineNo + + # print ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode]) + return self.__ObjBinBuf + + def SetObjBin(self, ObjBinLen): + + self.__ObjBinLen = ObjBinLen + if self.__DelayEmit == False and gCreateOp == True: + self.__ObjBinBuf = gCFormPkg.IfrBinBufferGet(self.__ObjBinLen) + + def SetLineNo(self, LineNo): + self.__LineNo = LineNo + + def GetObjBinAddr(self, Addr): + self.__ObjBinBuf = Addr + return self.__ObjBinBuf + + def GetObjBinOffset(self): + return self.__PkgOffset + + def GetObjBinLen(self): + return self.__ObjBinLen + + def ExpendObjBin(self, Size): + if (self.__DelayEmit) == True and ( + (self.__ObjBinLen + Size) > self.__ObjBinLen): + self.__ObjBinLen = self.__ObjBinLen + Size + return True + else: + return False + + def ShrinkObjBin(self, Size): + if (self.__DelayEmit) == True and (self.__ObjBinLen > Size): + self.__ObjBinLen = self.__ObjBinLen - Size + + def GetObjBin(self): + return self.__ObjBinBuf + + def EMIT_PENDING_OBJ(self): + if self.__DelayEmit == False or gCreateOp == False: + return + + self.__PkgOffset = gCFormPkg.GetPkgLength() + # update data buffer to package data + self.__ObjBinBuf = gCFormPkg.IfrBinBufferGet(self.__ObjBinLen) + + self.__DelayEmit = False + + +gScopeCount = 0 +gIsOrderedList = False +gIsStringOp = False +gCurrentQuestion = None +gCurrentMinMaxData = None + + +def SetCurrentQuestion(Question): + + gCurrentQuestion = Question + return gCurrentQuestion + + +class CIfrOpHeader(): + + def __init__(self, OpHeader: EFI_IFR_OP_HEADER, OpCode=None, Length=0): + self.__OpHeader = OpHeader + if OpCode != None: + self.__OpHeader.OpCode = OpCode + + self.__OpHeader.Length = gOpcodeSizesScopeTable[ + OpCode].Size if Length == 0 else Length + self.__OpHeader.Scope = 1 if ( + gOpcodeSizesScopeTable[OpCode].Scope + gScopeCount > 0) else 0 + + def GetLength(self): + return self.__OpHeader.Length + + def SetScope(self, Scope): + self.__OpHeader.Scope = Scope + + def GetScope(self): + return self.__OpHeader.Scope + + def UpdateHeader(self, Header): + self.__OpHeader = Header + + def IncLength(self, Size): + self.__OpHeader.Length += Size + + def DecLength(self, Size): + self.__OpHeader.Length -= Size + + def GetOpCode(self): + return self.__OpHeader.OpCode + + +class CIfrStatementHeader(): + + def __init__(self, sHeader: EFI_IFR_STATEMENT_HEADER): + self.__sHeader = sHeader + self.__sHeader.Help = EFI_STRING_ID_INVALID + self.__sHeader.Prompt = EFI_STRING_ID_INVALID + + def GetStatementHeader(self): + return self.__sHeader + + def SetPrompt(self, Prompt): + self.__sHeader.Prompt = Prompt + + def SetHelp(self, Help): + self.__sHeader.Help = Help + + +class CIfrMinMaxStepData(): + + def __init__(self, MinMaxStepData, NumericOpcode=False): + self.__MinMaxStepData = MinMaxStepData + self.__MinMaxStepData.u64.MinValue = 0 + self.__MinMaxStepData.u64.MaxValue = 0 + self.__MinMaxStepData.u64.Step = 0 + self.__ValueIsSet = False + self.__IsNumeric = NumericOpcode + self.__VarType = EFI_IFR_TYPE_NUM_SIZE_64 + + def SetMinMaxStepData(self, MinValue, MaxValue, Step, VarType): + self.__VarType = VarType + + if self.__ValueIsSet == False: + if VarType == EFI_IFR_TYPE_NUM_SIZE_64: + self.__MinMaxStepData.u64.MinValue = MinValue + self.__MinMaxStepData.u64.MaxValue = MaxValue + self.__MinMaxStepData.u64.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_32: + self.__MinMaxStepData.u32.MinValue = MinValue + self.__MinMaxStepData.u32.MaxValue = MaxValue + self.__MinMaxStepData.u32.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_16: + self.__MinMaxStepData.u16.MinValue = MinValue + self.__MinMaxStepData.u16.MaxValue = MaxValue + self.__MinMaxStepData.u16.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_8: + self.__MinMaxStepData.u8.MinValue = MinValue + self.__MinMaxStepData.u8.MaxValue = MaxValue + self.__MinMaxStepData.u8.Step = Step + self.__ValueIsSet = True + else: + if VarType == EFI_IFR_TYPE_NUM_SIZE_64: + if MinValue < self.__MinMaxStepData.u64.MinValue: + self.__MinMaxStepData.u64.MinValue = MinValue + if MaxValue > self.__MinMaxStepData.u64.MaxValue: + self.__MinMaxStepData.u64.MaxValue = MaxValue + self.__MinMaxStepData.u64.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_32: + if MinValue < self.__MinMaxStepData.u32.MinValue: + self.__MinMaxStepData.u32.MinValue = MinValue + if MaxValue > self.__MinMaxStepData.u32.MaxValue: + self.__MinMaxStepData.u32.MaxValue = MaxValue + self.__MinMaxStepData.u32.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_16: + if MinValue < self.__MinMaxStepData.u16.MinValue: + self.__MinMaxStepData.u16.MinValue = MinValue + if MaxValue > self.__MinMaxStepData.u16.MaxValue: + self.__MinMaxStepData.u16.MaxValue = MaxValue + self.__MinMaxStepData.u16.Step = Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_8: + if MinValue < self.__MinMaxStepData.u8.MinValue: + self.__MinMaxStepData.u8.MinValue = MinValue + if MaxValue > self.__MinMaxStepData.u8.MaxValue: + self.__MinMaxStepData.u8.MaxValue = MaxValue + self.__MinMaxStepData.u8.Step = Step + + def GetVarType(self): + return self.__VarType + + def IsNumericOpcode(self): + return self.__IsNumeric + + def UpdateCIfrMinMaxStepData(self, MinMaxStepData): + self.__MinMaxStepData = MinMaxStepData + + def GetMinData(self, VarType, IsBitVar): + + if IsBitVar: + return self.__MinMaxStepData.u32.MinValue + + else: + if VarType == EFI_IFR_TYPE_NUM_SIZE_64: + return self.__MinMaxStepData.u64.MinValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_32: + return self.__MinMaxStepData.u32.MinValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_16: + return self.__MinMaxStepData.u16.MinValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_8: + return self.__MinMaxStepData.u8.MinValue + + return 0 + + def GetMaxData(self, VarType, IsBitVar): + + if IsBitVar: + return self.__MinMaxStepData.u32.MaxValue + + else: + if VarType == EFI_IFR_TYPE_NUM_SIZE_64: + return self.__MinMaxStepData.u64.MaxValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_32: + return self.__MinMaxStepData.u32.MaxValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_16: + return self.__MinMaxStepData.u16.MaxValue + if VarType == EFI_IFR_TYPE_NUM_SIZE_8: + return self.__MinMaxStepData.u8.MaxValue + + return 0 + + def GetStepData(self, VarType, IsBitVar): + + if IsBitVar: + return self.__MinMaxStepData.u32.Step + + else: + if VarType == EFI_IFR_TYPE_NUM_SIZE_64: + return self.__MinMaxStepData.u64.Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_32: + return self.__MinMaxStepData.u32.Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_16: + return self.__MinMaxStepData.u16.Step + if VarType == EFI_IFR_TYPE_NUM_SIZE_8: + return self.__MinMaxStepData.u8.Step + + return 0 + + +class CIfrFormSet(CIfrObj, CIfrOpHeader): + + def __init__(self, Size): + self.__FormSet = EFI_IFR_FORM_SET() + CIfrObj.__init__(self, self.__FormSet, EFI_IFR_FORM_SET_OP) + CIfrOpHeader.__init__(self, self.__FormSet.Header, EFI_IFR_FORM_SET_OP, + Size) + self.__FormSet.Help = EFI_STRING_ID_INVALID + self.__FormSet.FormSetTitle = EFI_STRING_ID_INVALID + self.__FormSet.Flags = 0 + self.__FormSet.Guid = EFI_GUID(0, 0, 0, + GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + self.__ClassGuid = [] + + def SetGuid(self, Guid): + self.__FormSet.Guid = Guid + + def GetGuid(self): + return self.__FormSet.Guid + + def SetFormSetTitle(self, FormSetTitle): + self.__FormSet.FormSetTitle = FormSetTitle + + def GetFormSetTitle(self): + return self.__FormSet.FormSetTitle + + def SetHelp(self, Help): + self.__FormSet.Help = Help + + def GetHelp(self): + return self.__FormSet.Help + + def SetClassGuid(self, Guid): + self.__ClassGuid.append(Guid) + self.__FormSet.Flags += 1 + + def GetClassGuid(self): + return self.__ClassGuid + + def GetFlags(self): + return self.__FormSet.Flags + + def GetInfo(self): + return self.__FormSet + + +class CIfrOneOfOption(CIfrObj, CIfrOpHeader): + + def __init__(self, Size): + self.__OneOfOption = EFI_IFR_ONE_OF_OPTION() + CIfrOpHeader.__init__(self, self.__OneOfOption.Header, + EFI_IFR_ONE_OF_OPTION_OP, Size) + self.__OneOfOption.Flags = 0 + self.__OneOfOption.Option = EFI_STRING_ID_INVALID + self.__OneOfOption.Type = EFI_IFR_TYPE_OTHER + self.__OneOfOption.Value = EFI_IFR_TYPE_VALUE() + + def SetOption(self, Option): + self.__OneOfOption.Option = Option + + def SetType(self, Type): + self.__OneOfOption.Type = Type + + def SetValue(self, Value): + self.__OneOfOption.Value = Value + + def GetFlags(self): + return self.__OneOfOption.Flags + + def SetFlags(self, LFlags): + + self.__OneOfOption.Flags = 0 + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT) + if Ret: + self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT_MFG) + if Ret: + self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT_MFG + + if LFlags == EFI_IFR_TYPE_NUM_SIZE_8: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_8) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_8 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_16: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_16) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_16 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_32: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_32) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_32 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_64: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_64) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_64 + + elif LFlags == EFI_IFR_TYPE_BOOLEAN: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_BOOLEAN) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_BOOLEAN + + elif LFlags == EFI_IFR_TYPE_TIME: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_TIME) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_TIME + + elif LFlags == EFI_IFR_TYPE_DATE: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_DATE) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_DATE + + elif LFlags == EFI_IFR_TYPE_STRING: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_STRING) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_STRING + + elif LFlags == EFI_IFR_TYPE_OTHER: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_OTHER) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_OTHER + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__OneOfOption + + +class CIfrOneOfOption2(CIfrObj, CIfrOpHeader): + + def __init__(self, Size, Nums, ValueType, ValueList=[]): + self.__OneOfOption = Refine_EFI_IFR_ONE_OF_OPTION(Nums) + Header = EFI_IFR_OP_HEADER() + CIfrOpHeader.__init__(self, Header, EFI_IFR_ONE_OF_OPTION_OP, Size) + self.__OneOfOption.Header = Header + self.__OneOfOption.Flags = 0 + self.__OneOfOption.Option = EFI_STRING_ID_INVALID + self.__OneOfOption.Type = EFI_IFR_TYPE_OTHER + self.__ValueType = ValueType + if ValueList != []: + ArrayType = EFI_IFR_TYPE_VALUE * Nums + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__OneOfOption.Value = ValueArray + + def SetOption(self, Option): + self.__OneOfOption.Option = Option + + def SetType(self, Type): + self.__OneOfOption.Type = Type + + def GetValueType(self): + return self.__ValueType + + def SetValue(self, ValueList): + ArrayType = EFI_IFR_TYPE_VALUE * (len(ValueList)) + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__OneOfOption.Value = ValueArray + + def GetFlags(self): + return self.__OneOfOption.Flags + + def SetFlags(self, LFlags): + + self.__OneOfOption.Flags = 0 + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT) + if Ret: + self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT_MFG) + if Ret: + self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT_MFG + + if LFlags == EFI_IFR_TYPE_NUM_SIZE_8: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_8) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_8 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_16: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_16) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_16 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_32: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_32) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_32 + + elif LFlags == EFI_IFR_TYPE_NUM_SIZE_64: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_64) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_64 + + elif LFlags == EFI_IFR_TYPE_BOOLEAN: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_BOOLEAN) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_BOOLEAN + + elif LFlags == EFI_IFR_TYPE_TIME: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_TIME) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_TIME + + elif LFlags == EFI_IFR_TYPE_DATE: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_DATE) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_DATE + + elif LFlags == EFI_IFR_TYPE_STRING: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_STRING) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_STRING + + elif LFlags == EFI_IFR_TYPE_OTHER: + LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_OTHER) + self.__OneOfOption.Flags |= EFI_IFR_TYPE_OTHER + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__OneOfOption + + +class CIfrOptionKey(CIfrObj, CIfrOpHeader): + + def __init__(self, QuestionId, OptionValue, KeyValue): + + self.__OptionKey = EFI_IFR_GUID_OPTIONKEY() + CIfrOpHeader.__init__(self, self.__OptionKey.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_OPTIONKEY)) + self.__OptionKey.ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY + self.__OptionKey.Guid = EFI_IFR_FRAMEWORK_GUID + self.__OptionKey.QuestionId = QuestionId + self.__OptionKey.OptionValue = OptionValue + self.__OptionKey.KeyValue = KeyValue + + def GetInfo(self): + return self.__OptionKey + + +class CIfrClass(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Class = EFI_IFR_GUID_CLASS() # static guid + CIfrOpHeader.__init__(self, self.__Class.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_CLASS)) + self.__Class.ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS + self.__Class.Guid = EFI_IFR_TIANO_GUID + self.__Class.Class = EFI_NON_DEVICE_CLASS + + def SetClass(self, Class): + self.__Class.Class = Class + + def GetInfo(self): + return self.__Class + + +class CIfrSubClass(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__SubClass = EFI_IFR_GUID_SUBCLASS() # static guid + CIfrOpHeader.__init__(self, self.__SubClass.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_SUBCLASS)) + self.__SubClass.ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS + self.__SubClass.Guid = EFI_IFR_TIANO_GUID + self.__SubClass.SubClass = EFI_SETUP_APPLICATION_SUBCLASS + + def SetSubClass(self, SubClass): + self.__SubClass.SubClass = SubClass + + def GetInfo(self): + return self.__SubClass + + +class CIfrDefaultStore(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__DefaultStore = EFI_IFR_DEFAULTSTORE() + CIfrOpHeader.__init__(self, self.__DefaultStore.Header, + EFI_IFR_DEFAULTSTORE_OP) + self.__DefaultStore.DefaultName = EFI_STRING_ID_INVALID + self.__DefaultStore.DefaultId = EFI_VARSTORE_ID_INVALID + + def SetDefaultName(self, DefaultName): + self.__DefaultStore.DefaultName = DefaultName + + def SetDefaultId(self, DefaultId): + self.__DefaultStore.DefaultId = DefaultId + + def GetDefaultStore(self): + return self.__DefaultStore + + def SetDefaultStore(self, DefaultStore: EFI_IFR_DEFAULTSTORE): + self.__DefaultStore = DefaultStore + + def GetInfo(self): + return self.__DefaultStore + + +class CIfrVarStore(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Varstore = EFI_IFR_VARSTORE() + CIfrOpHeader.__init__(self, self.__Varstore.Header, + EFI_IFR_VARSTORE_OP) + self.__Varstore.VarStoreId = EFI_VARSTORE_ID_INVALID + self.__Varstore.Size = 0 + self.__Varstore.Name = '' + + def SetGuid(self, Guid): + self.__Varstore.Guid = Guid + + def SetSize(self, Size): + self.__Varstore.Size = Size + + def SetVarStoreId(self, VarStoreId): + self.__Varstore.VarStoreId = VarStoreId + + def SetName(self, Name): + self.__Varstore.Name = Name + + def GetInfo(self): + return self.__Varstore + + +class CIfrVarStoreEfi(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__VarStoreEfi = EFI_IFR_VARSTORE_EFI() + CIfrOpHeader.__init__(self, self.__VarStoreEfi.Header, + EFI_IFR_VARSTORE_EFI_OP) + self.__VarStoreEfi.VarStoreId = EFI_VAROFFSET_INVALID + self.__VarStoreEfi.Size = 0 + self.__VarStoreEfi.Name = '' + + def SetGuid(self, Guid): + self.__VarStoreEfi.Guid = Guid + + def SetSize(self, Size): + self.__VarStoreEfi.Size = Size + + def SetVarStoreId(self, VarStoreId): + self.__VarStoreEfi.VarStoreId = VarStoreId + + def SetName(self, Name): + self.__VarStoreEfi.Name = Name + + def SetAttributes(self, Attributes): + self.__VarStoreEfi.Attributes = Attributes + + def GetInfo(self): + return self.__VarStoreEfi + + +class CIfrVarStoreNameValue(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__VarStoreNameValue = EFI_IFR_VARSTORE_NAME_VALUE() + CIfrOpHeader.__init__(self, self.__VarStoreNameValue.Header, + EFI_IFR_VARSTORE_NAME_VALUE_OP) + self.__VarStoreNameValue.VarStoreId = EFI_VAROFFSET_INVALID + + def SetGuid(self, Guid): + self.__VarStoreNameValue.Guid = Guid + + def SetVarStoreId(self, VarStoreId): + self.__VarStoreNameValue.VarStoreId = VarStoreId + + def GetInfo(self): + return self.__VarStoreNameValue + + +EFI_BITS_PER_UINT32 = 1 << EFI_BITS_SHIFT_PER_UINT32 +EFI_FORM_ID_MAX = 0xFFFF + +EFI_FREE_FORM_ID_BITMAP_SIZE = int((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32) + + +class CIfrFormId(): + + FormIdBitMap = [] + for i in range(0, EFI_FREE_FORM_ID_BITMAP_SIZE): + FormIdBitMap.append(0) + + @classmethod + def CheckFormIdFree(cls, FormId): + + Index = int(FormId / EFI_BITS_PER_UINT32) + Offset = FormId % EFI_BITS_PER_UINT32 + + return (cls.FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0 + + @classmethod + def MarkFormIdUsed(cls, FormId): + + Index = int(FormId / EFI_BITS_PER_UINT32) + Offset = FormId % EFI_BITS_PER_UINT32 + cls.FormIdBitMap[Index] |= (0x80000000 >> Offset) + + +class CIfrForm(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__Form = EFI_IFR_FORM() + CIfrOpHeader.__init__(self, self.__Form.Header, EFI_IFR_FORM_OP) + self.__Form.FormId = 0 + self.__Form.FormTitle = EFI_STRING_ID_INVALID + + def SetFormId(self, FormId): + # FormId can't be 0. + if FormId == 0: + return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER + if CIfrFormId.CheckFormIdFree(FormId) == False: + return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED + self.__Form.FormId = FormId + CIfrFormId.MarkFormIdUsed(FormId) + return VfrReturnCode.VFR_RETURN_SUCCESS + + def SetFormTitle(self, FormTitle): + self.__Form.FormTitle = FormTitle + + def GetInfo(self): + return self.__Form + + +class CIfrFormMap(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__FormMap = EFI_IFR_FORM_MAP() + self.__MethodMapList = [] # EFI_IFR_FORM_MAP_METHOD() + CIfrOpHeader.__init__(self, self.__FormMap.Header, EFI_IFR_FORM_MAP_OP) + self.__FormMap.FormId = 0 + + def SetFormId(self, FormId): + if FormId == 0: + return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER + + if CIfrFormId.CheckFormIdFree(FormId) == False: + return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED + self.__FormMap.FormId = FormId + CIfrFormId.MarkFormIdUsed(FormId) + return VfrReturnCode.VFR_RETURN_SUCCESS + + def SetFormMapMethod(self, MethodTitle, MethodGuid: EFI_GUID): + MethodMap = EFI_IFR_FORM_MAP_METHOD() + MethodMap.MethodTitle = MethodTitle + MethodMap.MethodIdentifier = MethodGuid + self.__MethodMapList.append(MethodMap) + + def GetInfo(self): + return self.__FormMap, self.__MethodMapList + + +class CIfrEnd(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__End = EFI_IFR_END() + CIfrOpHeader.__init__(self, self.__End.Header, EFI_IFR_END_OP) + + +class CIfrBanner(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Banner = EFI_IFR_GUID_BANNER() + CIfrOpHeader.__init__(self, self.__Banner.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_BANNER)) + self.__Banner.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER + self.__Banner.Guid = EFI_IFR_TIANO_GUID + + def SetTitle(self, StringId): + self.__Banner.Title = StringId + + def SetLine(self, Line): + self.__Banner.LineNumber = Line + + def SetAlign(self, Align): + self.__Banner.Alignment = Align + + def GetInfo(self): + return self.__Banner + + +class CIfrTimeout(CIfrObj, CIfrOpHeader): + + def __init__(self, Timeout=0): + self.__Timeout = EFI_IFR_GUID_TIMEOUT() + CIfrOpHeader.__init__(self, self.__Timeout.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_TIMEOUT)) + self.__Timeout.ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT + self.__Timeout.Guid = EFI_IFR_TIANO_GUID + self.__Timeout.TimeOut = Timeout + + def SetTimeout(self, Timeout): + self.__Timeout.TimeOut = Timeout + + def GetInfo(self): + return self.__Timeout + + +class CIfrLabel(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Label = EFI_IFR_GUID_LABEL() + CIfrOpHeader.__init__(self, self.__Label.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID_LABEL)) + self.__Label.ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL + self.__Label.Guid = EFI_IFR_TIANO_GUID + + def SetNumber(self, Number): + self.__Label.Number = Number + + def GetInfo(self): + return self.__Label + + +class CIfrRule(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Rule = EFI_IFR_RULE() + CIfrOpHeader.__init__(self, self.__Rule.Header, EFI_IFR_RULE_OP) + self.__Rule.RuleId = EFI_RULE_ID_INVALID + + def SetRuleId(self, RuleId): + self.__Rule.RuleId = RuleId + + def GetInfo(self): + return self.__Rule + + +def _FLAG_TEST_AND_CLEAR(Flags, Mask): + + Ret = Flags & Mask + Flags &= (~Mask) + return Flags, Ret + + +def _FLAG_CLEAR(Flags, Mask): + + Flags &= (~Mask) + return Flags + + +class CIfrSubtitle(CIfrObj, CIfrOpHeader, CIfrStatementHeader): + + def __init__(self, ): + self.__Subtitle = EFI_IFR_SUBTITLE() + + CIfrOpHeader.__init__(self, self.__Subtitle.Header, + EFI_IFR_SUBTITLE_OP) + CIfrStatementHeader.__init__(self, self.__Subtitle.Statement) + + self.__Subtitle.Flags = 0 + + def SetFlags(self, Flags): + Flags, Result = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAGS_HORIZONTAL) + if Result: + self.__Subtitle.Flags |= EFI_IFR_FLAGS_HORIZONTAL + + return VfrReturnCode.VFR_RETURN_SUCCESS if Flags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__Subtitle + + +class CIfrImage(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Image = EFI_IFR_IMAGE() + CIfrOpHeader.__init__(self, self.__Image.Header, EFI_IFR_IMAGE_OP) + self.__Image.Id = EFI_IMAGE_ID_INVALID + + def SetImageId(self, ImageId): + self.__Image.Id = ImageId + + def GetInfo(self): + return self.__Image + + +class CIfrLocked(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Lock = EFI_IFR_LOCKED() + CIfrOpHeader.__init__(self, self.__Lock.Header, EFI_IFR_LOCKED_OP) + + +class CIfrModal(CIfrObj, CIfrOpHeader): + + def __init__(self, ): + self.__Modal = EFI_IFR_MODAL_TAG() + CIfrOpHeader.__init__(self, self.__Modal.Header, EFI_IFR_MODAL_TAG_OP) + + +EFI_IFR_QUESTION_FLAG_DEFAULT = 0 + + +class CIfrQuestionHeader(CIfrStatementHeader): + + def __init__(self, qHeader, Flags=EFI_IFR_QUESTION_FLAG_DEFAULT): + + self.__qHeader = qHeader + CIfrStatementHeader.__init__(self, self.__qHeader.Header) + self.__qHeader.QuestionId = EFI_QUESTION_ID_INVALID + self.__qHeader.VarStoreId = EFI_VARSTORE_ID_INVALID + self.__qHeader.VarStoreInfo.VarName = EFI_STRING_ID_INVALID + self.__qHeader.VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID + self.__qHeader.Flags = Flags + + def GetQuestionId(self): + return self.__qHeader.QuestionId + + def SetQuestionId(self, QuestionId): + + self.__qHeader.QuestionId = QuestionId + + def GetVarStoreId(self): + return self.__qHeader.VarStoreId + + def SetVarStoreInfo(self, BaseInfo): + + self.__qHeader.VarStoreId = BaseInfo.VarStoreId + self.__qHeader.VarStoreInfo.VarName = BaseInfo.Info.VarName + self.__qHeader.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset + + def GetVarStoreInfo(self, Info): # Bug + + Info.VarStoreId = self.__qHeader.VarStoreId + Info.VarStoreInfo = self.__qHeader.VarStoreInfo + return Info + + def GetFlags(self): + return self.__qHeader.Flags + + def SetFlags(self, Flags): + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_READ_ONLY) + if Ret: + self.__qHeader.Flags |= EFI_IFR_FLAG_READ_ONLY + + Flags = _FLAG_CLEAR(Flags, 0x02) + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_CALLBACK) + if Ret: + self.__qHeader.Flags |= EFI_IFR_FLAG_CALLBACK + + # ignore NVAccessFlag + Flags = _FLAG_CLEAR(Flags, 0x08) + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_RESET_REQUIRED) + if Ret: + self.__qHeader.Flags |= EFI_IFR_FLAG_RESET_REQUIRED + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, + EFI_IFR_FLAG_RECONNECT_REQUIRED) + if Ret: + self.__qHeader.Flags |= EFI_IFR_FLAG_RECONNECT_REQUIRED + + # Set LateCheck Flag to compatible for framework flag + # but it uses 0x20 as its flag, if in the future UEFI may take this flag + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, 0x20) + if Ret: + self.__qHeader.Flags |= 0x20 + + Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_OPTIONS_ONLY) + if Ret: + self.__qHeader.Flags |= EFI_IFR_FLAG_OPTIONS_ONLY + + return VfrReturnCode.VFR_RETURN_SUCCESS if Flags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def UpdateCIfrQuestionHeader(self, qHeader): + self.__qHeader = qHeader + + +class CIfrRef(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Ref = EFI_IFR_REF() + CIfrOpHeader.__init__(self, self.__Ref.Header, EFI_IFR_REF_OP) + CIfrQuestionHeader.__init__(self, self.__Ref.Question) + self.__Ref.FormId = 0 + + def SetFormId(self, FormId): + self.__Ref.FormId = FormId + + def GetInfo(self): + return self.__Ref + + +class CIfrRef2(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Ref2 = EFI_IFR_REF2() + CIfrOpHeader.__init__(self, self.__Ref2.Header, EFI_IFR_REF_OP) + CIfrQuestionHeader.__init__(self, self.__Ref2.Question) + self.__Ref2.FormId = 0 + self.__Ref2.QuestionId = EFI_QUESTION_ID_INVALID + + def SetFormId(self, FormId): + self.__Ref2.FormId = FormId + + def SetQuestionId(self, QuestionId): + + self.__Ref2.QuestionId = QuestionId + + def GetInfo(self): + return self.__Ref2 + + +class CIfrRef3(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Ref3 = EFI_IFR_REF3() + CIfrOpHeader.__init__(self, self.__Ref3.Header, EFI_IFR_REF_OP) + CIfrQuestionHeader.__init__(self, self.__Ref3.Question) + self.__Ref3.FormId = 0 + self.__Ref3.QuestionId = EFI_QUESTION_ID_INVALID + EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0, + GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + self.__Ref3.FormSetId = EFI_IFR_DEFAULT_GUID + + def SetFormId(self, FormId): + self.__Ref3.FormId = FormId + + def SetQuestionId(self, QuestionId): + + self.__Ref3.QuestionId = QuestionId + + def SetFormSetId(self, FormSetId): + self.__Ref3.FormSetId = FormSetId + + def GetInfo(self): + return self.__Ref3 + + +class CIfrRef4(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Ref4 = EFI_IFR_REF4() + CIfrOpHeader.__init__(self, self.__Ref4.Header, EFI_IFR_REF_OP) + CIfrQuestionHeader.__init__(self, self.__Ref4.Question) + self.__Ref4.FormId = 0 + self.__Ref4.QuestionId = EFI_QUESTION_ID_INVALID + EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0, + GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + self.__Ref4.FormSetId = EFI_IFR_DEFAULT_GUID + self.__Ref4.DevicePath = EFI_STRING_ID_INVALID + + def SetFormId(self, FormId): + self.__Ref4.FormId = FormId + + def SetQuestionId(self, QuestionId): + + self.__Ref4.QuestionId = QuestionId + + def SetFormSetId(self, FormSetId): + self.__Ref4.FormSetId = FormSetId + + def SetDevicePath(self, DevicePath): + self.__Ref4.DevicePath = DevicePath + + def GetInfo(self): + return self.__Ref4 + + +class CIfrRef5(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Ref5 = EFI_IFR_REF5() + CIfrOpHeader.__init__(self, self.__Ref5.Header, EFI_IFR_REF_OP) + CIfrQuestionHeader.__init__(self, self.__Ref5.Question) + + def GetInfo(self): + return self.__Ref5 + + +class CIfrAction(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self, ): + self.__Action = EFI_IFR_ACTION() + CIfrOpHeader.__init__(self, self.__Action.Header, EFI_IFR_ACTION_OP) + CIfrQuestionHeader.__init__(self, self.__Action.Question) + self.__Action.QuestionConfig = EFI_STRING_ID_INVALID + + def SetQuestionConfig(self, QuestionConfig): + self.__Action.QuestionConfig = QuestionConfig + + def GetInfo(self): + return self.__Action + + +class CIfrText(CIfrObj, CIfrOpHeader, CIfrStatementHeader): + + def __init__(self, ): + self.__Text = EFI_IFR_TEXT() + CIfrOpHeader.__init__(self, self.__Text.Header, EFI_IFR_TEXT_OP) + CIfrStatementHeader.__init__(self, self.__Text.Statement) + self.__Text.TextTwo = EFI_STRING_ID_INVALID + + def SetTextTwo(self, StringId): + self.__Text.TextTwo = StringId + + def GetInfo(self): + return self.__Text + + +class CIfrGuid(CIfrObj, CIfrOpHeader): + + def __init__(self, Size, Databuff=None): + self.__Guid = EFI_IFR_GUID() + self.__Data = Databuff + CIfrOpHeader.__init__(self, self.__Guid.Header, EFI_IFR_GUID_OP, + ctypes.sizeof(EFI_IFR_GUID) + Size) + EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0, + GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + self.__Guid.Guid = EFI_IFR_DEFAULT_GUID + + def SetGuid(self, Guid): + self.__Guid.Guid = Guid + + def SetData(self, Databuff): + self.__Data = Databuff + + def GetInfo(self): + return self.__Guid + + +class CIfrOrderedList(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__OrderedList = EFI_IFR_ORDERED_LIST() + CIfrOpHeader.__init__(self, self.__OrderedList.Header, + EFI_IFR_ORDERED_LIST_OP) + CIfrQuestionHeader.__init__(self, self.__OrderedList.Question) + self.__OrderedList.MaxContainers = 0 + self.__OrderedList.Flags = 0 + + def GetQuestion(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def SetMaxContainers(self, MaxContainers): + self.__OrderedList.MaxContainers = MaxContainers + + def SetFlags(self, HFlags, LFlags): + + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_UNIQUE_SET) + if Ret: + self.__OrderedList.Flags |= EFI_IFR_UNIQUE_SET + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_NO_EMPTY_SET) + if Ret: + self.__OrderedList.Flags |= EFI_IFR_NO_EMPTY_SET + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__OrderedList + + +class CIfrString(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__Str = EFI_IFR_STRING() + CIfrOpHeader.__init__(self, self.__Str.Header, EFI_IFR_STRING_OP) + CIfrQuestionHeader.__init__(self, self.__Str.Question) + self.__Str.Flags = 0 + self.__Str.MinSize = 0 + self.__Str.MaxSize = 0 + + def GetQuestion(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def SetFlags(self, HFlags, LFlags): + + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_STRING_MULTI_LINE) + if Ret: + self.__Str.Flags |= EFI_IFR_STRING_MULTI_LINE + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def SetMinSize(self, MinSize): + self.__Str.MinSize = MinSize + + def SetMaxSize(self, MaxSize): + self.__Str.MaxSize = MaxSize + + def GetInfo(self): + return self.__Str + + +class CIfrPassword(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__Password = EFI_IFR_PASSWORD() + CIfrOpHeader.__init__(self, self.__Password.Header, + EFI_IFR_PASSWORD_OP) + CIfrQuestionHeader.__init__(self, self.__Password.Question) + self.__Password.MinSize = 0 + self.__Password.MaxSize = 0 + + def GetQuestion(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def SetMinSize(self, MinSize): + self.__Password.MinSize = MinSize + + def SetMaxSize(self, MaxSize): + self.__Password.MaxSize = MaxSize + + def GetInfo(self): + return self.__Password + + +class CIfrDefault(CIfrObj, CIfrOpHeader): + + def __init__(self, + Size, + DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD, + Type=EFI_IFR_TYPE_OTHER, + Value=EFI_IFR_TYPE_VALUE()): + self.__Default = EFI_IFR_DEFAULT() + CIfrOpHeader.__init__(self, self.__Default.Header, EFI_IFR_DEFAULT_OP, + Size) + self.__Default.Type = Type + self.__Default.DefaultId = DefaultId + self.__Default.Value = Value + + def SetDefaultId(self, DefaultId): + self.__Default.DefaultId = DefaultId + + def SetType(self, Type): + self.__Default.Type = Type + + def SetValue(self, Value): + self.__Default.Value = Value + + def GetInfo(self): + return self.__Default + + +class CIfrDefault3(CIfrObj, CIfrOpHeader): + + def __init__(self, + Size, + Nums, + ValueType, + DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD, + Type=EFI_IFR_TYPE_OTHER, + ValueList=[]): + Header = EFI_IFR_OP_HEADER() + CIfrOpHeader.__init__(self, Header, EFI_IFR_DEFAULT_OP, Size) + self.__Default = Refine_EFI_IFR_DEFAULT(Nums) + self.__Default.Header = Header + self.__Default.Type = Type + self.__Default.DefaultId = DefaultId + self.__ValueType = ValueType + + if ValueList != []: + ArrayType = EFI_IFR_TYPE_VALUE * Nums + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__Default.Value = ValueArray + + def SetDefaultId(self, DefaultId): + self.__Default.DefaultId = DefaultId + + def GetValueType(self): + return self.__ValueType + + def SetType(self, Type): + self.__Default.Type = Type + + def SetValue(self, ValueList): + ArrayType = EFI_IFR_TYPE_VALUE * (len(ValueList)) + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__Default.Value = ValueArray + + def GetInfo(self): + return self.__Default + + +class CIfrDefault2(CIfrObj, CIfrOpHeader): + + def __init__(self, + DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD, + Type=EFI_IFR_TYPE_OTHER): + self.__Default = EFI_IFR_DEFAULT_2() + CIfrOpHeader.__init__(self, self.__Default.Header, EFI_IFR_DEFAULT_OP) + self.__Default.Type = Type + self.__Default.DefaultId = DefaultId + + def SetDefaultId(self, DefaultId): + self.__Default.DefaultId = DefaultId + + def SetType(self, Type): + self.__Default.Type = Type + + def GetInfo(self): + return self.__Default + + +class CIfrInconsistentIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__InconsistentIf = EFI_IFR_INCONSISTENT_IF() + CIfrOpHeader.__init__(self, self.__InconsistentIf.Header, + EFI_IFR_INCONSISTENT_IF_OP) + self.__InconsistentIf.Error = EFI_STRING_ID_INVALID + + def SetError(self, Error): + self.__InconsistentIf.Error = Error + + +class CIfrNoSubmitIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__NoSubmitIf = EFI_IFR_NO_SUBMIT_IF() + CIfrOpHeader.__init__(self, self.__NoSubmitIf.Header, + EFI_IFR_NO_SUBMIT_IF_OP) + self.__NoSubmitIf.Error = EFI_STRING_ID_INVALID + + def SetError(self, Error): + self.__NoSubmitIf.Error = Error + + +class CIfrDisableIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__DisableIf = EFI_IFR_DISABLE_IF() + CIfrOpHeader.__init__(self, self.__DisableIf.Header, + EFI_IFR_DISABLE_IF_OP) + + +class CIfrSuppressIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__SuppressIf = EFI_IFR_SUPPRESS_IF() + CIfrOpHeader.__init__(self, self.__SuppressIf.Header, + EFI_IFR_SUPPRESS_IF_OP) + + +class CIfrGrayOutIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__GrayOutIf = EFI_IFR_GRAY_OUT_IF() + CIfrOpHeader.__init__(self, self.__GrayOutIf.Header, + EFI_IFR_GRAY_OUT_IF_OP) + + +class CIfrValue(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__Value = EFI_IFR_VALUE() + CIfrOpHeader.__init__(self, self.__Value.Header, EFI_IFR_VALUE_OP) + + +class CIfrRead(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__Read = EFI_IFR_READ() + CIfrOpHeader.__init__(self, self.__Read.Header, EFI_IFR_READ_OP) + + +class CIfrWrite(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__Write = EFI_IFR_WRITE() + CIfrOpHeader.__init__(self, self.__Write.Header, EFI_IFR_WRITE_OP) + + +class CIfrWarningIf(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__WarningIf = EFI_IFR_WARNING_IF() + CIfrOpHeader.__init__(self, self.__WarningIf.Header, + EFI_IFR_WARNING_IF_OP) + self.__WarningIf.Warning = EFI_STRING_ID_INVALID + self.__WarningIf.TimeOut = 0 + + def SetWarning(self, Warning): + self.__WarningIf.Warning = Warning + + def SetTimeOut(self, TimeOut): + self.__WarningIf.TimeOut = TimeOut + + def GetInfo(self): + return self.__WarningIf + + +class CIfrRefresh(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__Refresh = EFI_IFR_REFRESH() + CIfrOpHeader.__init__(self, self.__Refresh.Header, EFI_IFR_REFRESH_OP) + self.__Refresh.RefreshInterval = 0 + + def SetRefreshInterval(self, RefreshInterval): + self.__Refresh.RefreshInterval = RefreshInterval + + def GetInfo(self): + return self.__Refresh + + +class CIfrRefreshId(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__RefreshId = EFI_IFR_REFRESH_ID() + CIfrOpHeader.__init__(self, self.__RefreshId.Header, + EFI_IFR_REFRESH_ID_OP) + self.__RefreshId.RefreshEventGroupId = EFI_GUID( + 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + + def SetRefreshEventGroutId(self, RefreshEventGroupId): + self.__RefreshId.RefreshEventGroupId = RefreshEventGroupId + + def GetInfo(self): + return self.__RefreshId + + +class CIfrVarStoreDevice(CIfrObj, CIfrOpHeader): + + def __init__(self): + self.__VarStoreDevice = EFI_IFR_VARSTORE_DEVICE() + CIfrOpHeader.__init__(self, self.__VarStoreDevice.Header, + EFI_IFR_VARSTORE_DEVICE_OP) + self.__VarStoreDevice.DevicePath = EFI_STRING_ID_INVALID + + def SetDevicePath(self, DevicePath): + self.__VarStoreDevice.DevicePath = DevicePath + + def GetInfo(self): + return self.__VarStoreDevice + + +class CIfrDate(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__Date = EFI_IFR_DATE() + CIfrOpHeader.__init__(self, self.__Date.Header, EFI_IFR_DATE_OP) + CIfrQuestionHeader.__init__(self, self.__Date.Question) + self.__Date.Flags = 0 + + def SetFlags(self, HFlags, LFlags): + + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_YEAR_SUPPRESS) + if Ret: + self.__Date.Flags |= EFI_QF_DATE_YEAR_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_MONTH_SUPPRESS) + if Ret: + self.__Date.Flags |= EFI_QF_DATE_MONTH_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_DAY_SUPPRESS) + if Ret: + self.__Date.Flags |= EFI_QF_DATE_DAY_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_NORMAL) + if Ret: + self.__Date.Flags |= QF_DATE_STORAGE_NORMAL + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_TIME) + if Ret: + self.__Date.Flags |= QF_DATE_STORAGE_TIME + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_WAKEUP) + if Ret: + self.__Date.Flags |= QF_DATE_STORAGE_WAKEUP + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__Date + + +class CIfrTime(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__Time = EFI_IFR_TIME() + CIfrOpHeader.__init__(self, self.__Time.Header, EFI_IFR_TIME_OP) + CIfrQuestionHeader.__init__(self, self.__Time.Question) + self.__Time.Flags = 0 + + def SetFlags(self, HFlags, LFlags): + + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_HOUR_SUPPRESS) + if Ret: + self.__Time.Flags |= QF_TIME_HOUR_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_MINUTE_SUPPRESS) + if Ret: + self.__Time.Flags |= QF_TIME_MINUTE_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_SECOND_SUPPRESS) + if Ret: + self.__Time.Flags |= QF_TIME_SECOND_SUPPRESS + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_NORMAL) + if Ret: + self.__Time.Flags |= QF_TIME_STORAGE_NORMAL + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_TIME) + if Ret: + self.__Time.Flags |= QF_TIME_STORAGE_TIME + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_WAKEUP) + if Ret: + self.__Time.Flags |= QF_TIME_STORAGE_WAKEUP + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__Time + + +class CIfrNumeric(CIfrObj, CIfrOpHeader, CIfrQuestionHeader, + CIfrMinMaxStepData): + + def __init__(self): + self.__Numeric = EFI_IFR_NUMERIC() # data + CIfrOpHeader.__init__(self, self.__Numeric.Header, EFI_IFR_NUMERIC_OP) + CIfrQuestionHeader.__init__(self, self.__Numeric.Question) + CIfrMinMaxStepData.__init__(self, self.__Numeric.Data, True) + self.__Numeric.Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC + + def GetQuestion(self): + return self + + def GetMinMaxData(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def SetFlags(self, HFlags, LFlags, DisplaySettingsSpecified=False): + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + if DisplaySettingsSpecified == False: + self.__Numeric.Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC + else: + self.__Numeric.Flags = LFlags + return VfrReturnCode.VFR_RETURN_SUCCESS + + def SetFlagsForBitField(self, + HFlags, + LFlags, + DisplaySettingsSpecified=False): + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + if DisplaySettingsSpecified == False: + self.__Numeric.Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT + else: + self.__Numeric.Flags = LFlags + return VfrReturnCode.VFR_RETURN_SUCCESS + + def GetNumericFlags(self): + return self.__Numeric.Flags + + def ShrinkBinSize(self, Size): + self.ShrinkBinSize(Size) + self.DecLength(Size) + # _EMIT_PENDING_OBJ(); + Numeric = EFI_IFR_NUMERIC() + self.UpdateHeader(Numeric.Header) + + def GetInfo(self): + return self.__Numeric + + +class CIfrOneOf( + CIfrQuestionHeader, + CIfrObj, + CIfrOpHeader, +): + + def __init__(self): + self.__OneOf = EFI_IFR_ONE_OF() + CIfrOpHeader.__init__(self, self.__OneOf.Header, EFI_IFR_ONE_OF_OP) + CIfrQuestionHeader.__init__(self, self.__OneOf.Question) + self.__OneOf.Flags = 0 + + def GetQuestion(self): + return self + + def GetMinMaxData(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def SetFlags(self, HFlags, LFlags): + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + if LFlags & EFI_IFR_DISPLAY: + self.__OneOf.Flags = LFlags + else: + self.__OneOf.Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC + return VfrReturnCode.VFR_RETURN_SUCCESS + + def SetFlagsForBitField(self, HFlags, LFlags): + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + if LFlags & EDKII_IFR_DISPLAY_BIT: + self.__OneOf.Flags = LFlags + else: + self.__OneOf.Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT + return VfrReturnCode.VFR_RETURN_SUCCESS + + def GetInfo(self): + return self.__OneOf + + +class CIfrCheckBox(CIfrObj, CIfrOpHeader, CIfrQuestionHeader): + + def __init__(self): + self.__CheckBox = EFI_IFR_CHECKBOX() + CIfrOpHeader.__init__(self, self.__CheckBox.Header, + EFI_IFR_CHECKBOX_OP) + CIfrQuestionHeader.__init__(self, self.__CheckBox.Question) + self.__CheckBox.Flags = 0 + + def GetQuestion(self): + return self + + def SetQHeaderFlags(self, Flags): + CIfrQuestionHeader.SetFlags(self, Flags) + + def GetFlags(self): + return self.__CheckBox.Flags + + def SetFlags(self, HFlags, LFlags): + + ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags) + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS: + return ReturnCode + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_CHECKBOX_DEFAULT) + if Ret: + self.__CheckBox.Flags |= EFI_IFR_CHECKBOX_DEFAULT + + LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, + EFI_IFR_CHECKBOX_DEFAULT_MFG) + + if Ret: + self.__CheckBox.Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + def GetInfo(self): + return self.__CheckBox + + +class CIfrResetButton(CIfrObj, CIfrOpHeader, CIfrStatementHeader): + + def __init__(self): + self.__ResetButton = EFI_IFR_RESET_BUTTON() + CIfrOpHeader.__init__(self, self.__ResetButton.Header, + EFI_IFR_RESET_BUTTON_OP) + CIfrStatementHeader.__init__(self, self.__ResetButton.Statement) + self.__ResetButton.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD + + def SetDefaultId(self, DefaultId): + self.__ResetButton.DefaultId = DefaultId + + def GetInfo(self): + return self.__ResetButton + + +class CIfrOr(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Or = EFI_IFR_OR() + CIfrOpHeader.__init__(self, self.__Or.Header, EFI_IFR_OR_OP) + self.SetLineNo(LineNo) + + +class CIfrAnd(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__And = EFI_IFR_AND() + CIfrOpHeader.__init__(self, self.__And.Header, EFI_IFR_AND_OP) + self.SetLineNo(LineNo) + + +class CIfrBitWiseOr(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__BitWiseOr = EFI_IFR_BITWISE_OR() + CIfrOpHeader.__init__(self, self.__BitWiseOr.Header, + EFI_IFR_BITWISE_OR_OP) + self.SetLineNo(LineNo) + + +class CIfrCatenate(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Catenate = EFI_IFR_CATENATE() + CIfrOpHeader.__init__(self, self.__Catenate.Header, + EFI_IFR_CATENATE_OP) + self.SetLineNo(LineNo) + + +class CIfrDivide(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Divide = EFI_IFR_DIVIDE() + CIfrOpHeader.__init__(self, self.__Divide.Header, EFI_IFR_DIVIDE_OP) + self.SetLineNo(LineNo) + + +class CIfrEqual(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Equal = EFI_IFR_EQUAL() + CIfrOpHeader.__init__(self, self.__Equal.Header, EFI_IFR_EQUAL_OP) + self.SetLineNo(LineNo) + + +class CIfrGreaterEqual(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__GreaterEqual = EFI_IFR_GREATER_EQUAL() + CIfrOpHeader.__init__(self, self.__GreaterEqual.Header, + EFI_IFR_GREATER_EQUAL_OP) + self.SetLineNo(LineNo) + + +class CIfrGreaterThan(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__GreaterThan = EFI_IFR_GREATER_THAN() + CIfrOpHeader.__init__(self, self.__GreaterThan.Header, + EFI_IFR_GREATER_THAN_OP) + self.SetLineNo(LineNo) + + +class CIfrLessEqual(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__LessEqual = EFI_IFR_LESS_EQUAL() + CIfrOpHeader.__init__(self, self.__LessEqual.Header, + EFI_IFR_LESS_EQUAL_OP) + self.SetLineNo(LineNo) + + +class CIfrLessThan(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__LessThan = EFI_IFR_LESS_THAN() + CIfrOpHeader.__init__(self, self.__LessThan.Header, + EFI_IFR_LESS_THAN_OP) + self.SetLineNo(LineNo) + + +class CIfrMap(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Map = EFI_IFR_MAP() + CIfrOpHeader.__init__(self, self.__Map.Header, EFI_IFR_MAP_OP) + self.SetLineNo(LineNo) + + +class CIfrMatch(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Match = EFI_IFR_MATCH() + CIfrOpHeader.__init__(self, self.__Match.Header, EFI_IFR_MATCH_OP) + self.SetLineNo(LineNo) + + +class CIfrMatch2(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo, Guid): + self.__Match2 = EFI_IFR_MATCH2() + CIfrOpHeader.__init__(self, self.__Match2.Header, EFI_IFR_MATCH2_OP) + self.SetLineNo(LineNo) + self.__Match2.SyntaxType = Guid + + +class CIfrMultiply(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Multiply = EFI_IFR_MULTIPLY() + CIfrOpHeader.__init__(self, self.__Multiply.Header, + EFI_IFR_MULTIPLY_OP) + self.SetLineNo(LineNo) + + +class CIfrModulo(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Modulo = EFI_IFR_MODULO() + CIfrOpHeader.__init__(self, self.__Modulo.Header, EFI_IFR_MODULO_OP) + self.SetLineNo(LineNo) + + +class CIfrNotEqual(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__NotEqual = EFI_IFR_NOT_EQUAL() + CIfrOpHeader.__init__(self, self.__NotEqual.Header, + EFI_IFR_NOT_EQUAL_OP) + self.SetLineNo(LineNo) + + +class CIfrShiftLeft(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ShiftLeft = EFI_IFR_SHIFT_LEFT() + CIfrOpHeader.__init__(self, self.__ShiftLeft.Header, + EFI_IFR_SHIFT_LEFT_OP) + self.SetLineNo(LineNo) + + +class CIfrShiftRight(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ShiftRight = EFI_IFR_SHIFT_RIGHT() + CIfrOpHeader.__init__(self, self.__ShiftRight.Header, + EFI_IFR_SHIFT_RIGHT_OP) + self.SetLineNo(LineNo) + + +class CIfrSubtract(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Subtract = EFI_IFR_SUBTRACT() + CIfrOpHeader.__init__(self, self.__Subtract.Header, + EFI_IFR_SUBTRACT_OP) + self.SetLineNo(LineNo) + + +class CIfrConditional(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Conditional = EFI_IFR_CONDITIONAL() + CIfrOpHeader.__init__(self, self.__Conditional.Header, + EFI_IFR_CONDITIONAL_OP) + self.SetLineNo(LineNo) + + +class CIfrFind(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Find = EFI_IFR_FIND() + CIfrOpHeader.__init__(self, self.__Find.Header, EFI_IFR_FIND_OP) + self.SetLineNo(LineNo) + + def SetFormat(self, Format): + self.__Find.Format = Format + + +class CIfrMid(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Mid = EFI_IFR_MID() + CIfrOpHeader.__init__(self, self.__Mid.Header, EFI_IFR_MID_OP) + self.SetLineNo(LineNo) + + +class CIfrToken(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Token = EFI_IFR_TOKEN() + CIfrOpHeader.__init__(self, self.__Token.Header, EFI_IFR_TOKEN_OP) + self.SetLineNo(LineNo) + + +class CIfrSpan(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Span = EFI_IFR_SPAN() + CIfrOpHeader.__init__(self, self.__Span.Header, EFI_IFR_SPAN_OP) + self.SetLineNo(LineNo) + self.__Span.Flags = EFI_IFR_FLAGS_FIRST_MATCHING + + def SetFlags(self, LFlags): + if LFlags == EFI_IFR_FLAGS_FIRST_MATCHING: + self.__Span.Flags |= EFI_IFR_FLAGS_FIRST_MATCHING + else: + LFlags, Ret = _FLAG_TEST_AND_CLEAR( + LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING) + if Ret: + self.__Span.Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING + + return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED + + +class CIfrBitWiseAnd(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__BitWiseAnd = EFI_IFR_BITWISE_AND() + CIfrOpHeader.__init__(self, self.__BitWiseAnd.Header, + EFI_IFR_BITWISE_AND_OP) + self.SetLineNo(LineNo) + + +class CIfrBitWiseOr(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__BitWiseOr = EFI_IFR_BITWISE_OR() + CIfrOpHeader.__init__(self, self.__BitWiseOr.Header, + EFI_IFR_BITWISE_OR_OP) + self.SetLineNo(LineNo) + + +class CIfrAdd(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Add = EFI_IFR_ADD() + CIfrOpHeader.__init__(self, self.__Add.Header, EFI_IFR_ADD_OP) + self.SetLineNo(LineNo) + + +class CIfrToString(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ToString = EFI_IFR_TO_STRING() + CIfrOpHeader.__init__(self, self.__ToString.Header, + EFI_IFR_TO_STRING_OP) + self.SetLineNo(LineNo) + + def SetFormat(self, Format): + self.__ToString.Format = Format + + +class CIfrToUpper(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ToUppper = EFI_IFR_TO_UPPER() + CIfrOpHeader.__init__(self, self.__ToUppper.Header, + EFI_IFR_TO_UPPER_OP) + self.SetLineNo(LineNo) + + +class CIfrToUint(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ToUint = EFI_IFR_TO_UINT() + CIfrOpHeader.__init__(self, self.__ToUint.Header, EFI_IFR_TO_UINT_OP) + self.SetLineNo(LineNo) + + +class CIfrToLower(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__ToLower = EFI_IFR_TO_LOWER() + CIfrOpHeader.__init__(self, self.__ToLower.Header, EFI_IFR_TO_LOWER_OP) + self.SetLineNo(LineNo) + + +class CIfrToBoolean(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Boolean = EFI_IFR_TO_BOOLEAN() + CIfrOpHeader.__init__(self, self.__Boolean.Header, + EFI_IFR_TO_BOOLEAN_OP) + self.SetLineNo(LineNo) + + +class CIfrNot(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Not = EFI_IFR_NOT() + CIfrOpHeader.__init__(self, self.__Not.Header, EFI_IFR_NOT_OP) + self.SetLineNo(LineNo) + + +class CIfrDup(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Dup = EFI_IFR_DUP() + CIfrOpHeader.__init__(self, self.__Dup.Header, EFI_IFR_DUP_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__Dup.Header + + +class CIfrEqIdId(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__EqIdId = EFI_IFR_EQ_ID_ID() + CIfrOpHeader.__init__(self, self.__EqIdId.Header, EFI_IFR_EQ_ID_ID_OP) + self.SetLineNo(LineNo) + self.__EqIdId.QuestionId1 = EFI_QUESTION_ID_INVALID + self.__EqIdId.QuestionId2 = EFI_QUESTION_ID_INVALID + + def GetHeader(self): + return self.__EqIdId.Header + + def SetQuestionId1(self, QuestionId, VarIdStr, LineNo): + if QuestionId != EFI_QUESTION_ID_INVALID: + self.__EqIdId.QuestionId1 = QuestionId + else: + pass + + def SetQuestionId2(self, QuestionId, VarIdStr, LineNo): + if QuestionId != EFI_QUESTION_ID_INVALID: + self.__EqIdId.QuestionId2 = QuestionId + else: + pass + + +class CIfrEqIdVal(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__EqIdVal = EFI_IFR_EQ_ID_VAL() + CIfrOpHeader.__init__(self, self.__EqIdVal.Header, + EFI_IFR_EQ_ID_VAL_OP) + self.SetLineNo(LineNo) + self.__EqIdVal.QuestionId = EFI_QUESTION_ID_INVALID + + def SetQuestionId(self, QuestionId, VarIdStr, LineNo): + if QuestionId != EFI_QUESTION_ID_INVALID: + self.__EqIdVal.QuestionId = QuestionId + else: + pass + + def SetValue(self, Value): + self.__EqIdVal.Value = Value + + def GetHeader(self): + return self.__EqIdVal.Header + + +class CIfrEqIdList(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo, Nums, ValueList=[]): + self.__EqIdVList = Refine_EFI_IFR_EQ_ID_VAL_LIST(Nums) + Header = EFI_IFR_OP_HEADER() + CIfrOpHeader.__init__(self, Header, EFI_IFR_EQ_ID_VAL_OP) + self.SetLineNo(LineNo) + self.__EqIdVList.Header = Header + self.__EqIdVList.QuestionId = EFI_QUESTION_ID_INVALID + self.__EqIdVList.ListLength = 0 + if ValueList != []: + ArrayType = c_uint16 * Nums + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__EqIdVList.ValueList = ValueArray + + def SetQuestionId(self, QuestionId, VarIdStr, LineNo): + if QuestionId != EFI_QUESTION_ID_INVALID: + self.__EqIdVList.QuestionId = QuestionId + else: + pass + + def SetListLength(self, ListLength): + self.__EqIdVList.ListLength = ListLength + + def SetValueList(self, ValueList): + if ValueList != []: + ArrayType = c_uint16 * len(ValueList) + ValueArray = ArrayType() + for i in range(0, len(ValueList)): + ValueArray[i] = ValueList[i] + self.__EqIdVList.ValueList = ValueArray + + def GetHeader(self): + return self.__EqIdVList.Header + + +class CIfrUint8(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Uint8 = EFI_IFR_UINT8() + CIfrOpHeader.__init__(self, self.__Uint8.Header, EFI_IFR_UINT8_OP) + self.SetLineNo(LineNo) + + def SetValue(self, Value): + self.__Uint8.Value = Value + + def GetHeader(self): + return self.__Uint8.Header + + +class CIfrUint16(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Uint16 = EFI_IFR_UINT16() + CIfrOpHeader.__init__(self, self.__Uint16.Header, EFI_IFR_UINT16_OP) + self.SetLineNo(LineNo) + + def SetValue(self, Value): + self.__Uint16.Value = Value + + def GetHeader(self): + return self.__Uint16.Header + + +class CIfrUint32(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Uint32 = EFI_IFR_UINT32() + CIfrOpHeader.__init__(self, self.__Uint32.Header, EFI_IFR_UINT32_OP) + self.SetLineNo(LineNo) + + def SetValue(self, Value): + self.__Uint32.Value = Value + + def GetHeader(self): + return self.__Uint32.Header + + +class CIfrUint64(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Uint64 = EFI_IFR_UINT64() + CIfrOpHeader.__init__(self, self.__Uint64.Header, EFI_IFR_UINT64_OP) + self.SetLineNo(LineNo) + + def SetValue(self, Value): + self.__Uint64.Value = Value + + def GetHeader(self): + return self.__Uint64.Header + + +class CIfrQuestionRef1(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__QuestionRef1 = EFI_IFR_QUESTION_REF1() + CIfrOpHeader.__init__(self, self.__QuestionRef1.Header, + EFI_IFR_QUESTION_REF1_OP) + self.SetLineNo(LineNo) + self.__QuestionRef1.QuestionId = EFI_QUESTION_ID_INVALID + + def GetHeader(self): + return self.__QuestionRef1.Header + + def SetQuestionId(self, QuestionId, VarIdStr, LineNo): + if QuestionId != EFI_QUESTION_ID_INVALID: + self.__QuestionRef1.QuestionId = QuestionId + else: + pass + + +class CIfrQuestionRef2(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__QuestionRef2 = EFI_IFR_QUESTION_REF2() + CIfrOpHeader.__init__(self, self.__QuestionRef2.Header, + EFI_IFR_QUESTION_REF2_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__QuestionRef2.Header + + +class CIfrQuestionRef3(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__QuestionRef3 = EFI_IFR_QUESTION_REF3() + CIfrOpHeader.__init__(self, self.__QuestionRef3.Header, + EFI_IFR_QUESTION_REF3_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__QuestionRef3.Header + + +class CIfrQuestionRef3_2(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__QuestionRef3_2 = EFI_IFR_QUESTION_REF3_2() + CIfrOpHeader.__init__(self, self.__QuestionRef3_2.Header, + EFI_IFR_QUESTION_REF3_OP) + self.SetLineNo(LineNo) + self.__QuestionRef3_2.DevicePath = EFI_STRING_ID_INVALID + + def SetDevicePath(self, DevicePath): + self.__QuestionRef3_2.DevicePath = DevicePath + + def GetHeader(self): + return self.__QuestionRef3_2.Header + + +class CIfrQuestionRef3_3(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__QuestionRef3_3 = EFI_IFR_QUESTION_REF3_3() + CIfrOpHeader.__init__(self, self.__QuestionRef3_3.Header, + EFI_IFR_QUESTION_REF3_OP) + self.SetLineNo(LineNo) + self.__QuestionRef3_3.DevicePath = EFI_STRING_ID_INVALID + self.__QuestionRef3_3.Guid = EFI_GUID( + 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + + def SetDevicePath(self, DevicePath): + self.__QuestionRef3_3.DevicePath = DevicePath + + def SetGuid(self, Guid): + self.__QuestionRef3_3.Guid = Guid + + def GetHeader(self): + return self.__QuestionRef3_3.Header + + +class CIfrRuleRef(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__RuleRef = EFI_IFR_RULE_REF() + CIfrOpHeader.__init__(self, self.__RuleRef.Header, EFI_IFR_RULE_REF_OP) + self.SetLineNo(LineNo) + self.__RuleRef.RuleId = EFI_RULE_ID_INVALID + + def SetRuleId(self, RuleId): + self.__RuleRef.RuleId = RuleId + + def GetHeader(self): + return self.__RuleRef.Header + + +class CIfrStringRef1(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__StringRef1 = EFI_IFR_STRING_REF1() + CIfrOpHeader.__init__(self, self.__StringRef1.Header, + EFI_IFR_STRING_REF1_OP) + self.SetLineNo(LineNo) + self.__StringRef1.StringId = EFI_STRING_ID_INVALID + + def SetStringId(self, StringId): + self.__StringRef1.StringId = StringId + + def GetHeader(self): + return self.__StringRef1.Header + + +class CIfrStringRef2(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__StringRef2 = EFI_IFR_STRING_REF2() + CIfrOpHeader.__init__(self, self.__StringRef2.Header, + EFI_IFR_STRING_REF2_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__StringRef2.Header + + +class CIfrThis(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__This = EFI_IFR_THIS() + CIfrOpHeader.__init__(self, self.__This.Header, EFI_IFR_THIS_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__This.Header + + +class CIfrSecurity(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Security = EFI_IFR_SECURITY() + CIfrOpHeader.__init__(self, self.__Security.Header, + EFI_IFR_SECURITY_OP) + self.SetLineNo(LineNo) + self.__Security.Permissions = EFI_GUID( + 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0)) + + def SetPermissions(self, Permissions): + self.__Security.Permissions = Permissions + + def GetHeader(self): + return self.__Security.Header + + +class CIfrGet(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Get = EFI_IFR_GET() + CIfrOpHeader.__init__(self, self.__Get.Header, EFI_IFR_GET_OP) + self.SetLineNo(LineNo) + + def SetVarInfo(self, BaseInfo: EFI_VARSTORE_INFO): + self.__Get.VarStoreId = BaseInfo.VarStoreId + self.__Get.VarStoreInfo.VarName = BaseInfo.Info.VarName + self.__Get.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset + self.__Get.VarStoreType = BaseInfo.VarType + + def GetHeader(self): + return self.__Get.Header + + +class CIfrSet(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Set = EFI_IFR_SET() + CIfrOpHeader.__init__(self, self.__Set.Header, EFI_IFR_SET_OP) + self.SetLineNo(LineNo) + + def SetVarInfo(self, BaseInfo: EFI_VARSTORE_INFO): + self.__Set.VarStoreId = BaseInfo.VarStoreId + self.__Set.VarStoreInfo.VarName = BaseInfo.Info.VarName + self.__Set.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset + self.__Set.VarStoreType = BaseInfo.VarType + + def GetHeader(self): + return self.__Set.Header + + +class CIfrTrue(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__True = EFI_IFR_TRUE() + CIfrOpHeader.__init__(self, self.__True.Header, EFI_IFR_TRUE_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__True.Header + + +class CIfrFalse(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__False = EFI_IFR_TRUE() + CIfrOpHeader.__init__(self, self.__False.Header, EFI_IFR_FALSE_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__False.Header + + +class CIfrOne(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__One = EFI_IFR_ONE() + CIfrOpHeader.__init__(self, self.__One.Header, EFI_IFR_ONE_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__One.Header + + +class CIfrOnes(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Ones = EFI_IFR_ONE() + CIfrOpHeader.__init__(self, self.__Ones.Header, EFI_IFR_ONES_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__Ones.Header + + +class CIfrZero(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Zero = EFI_IFR_ZERO() + CIfrOpHeader.__init__(self, self.__Zero.Header, EFI_IFR_ZERO_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__Zero.Header + + +class CIfrUndefined(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Undefined = EFI_IFR_ZERO() + CIfrOpHeader.__init__(self, self.__Undefined.Header, + EFI_IFR_UNDEFINED_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__Undefined.Header + + +class CIfrVersion(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Version = EFI_IFR_VERSION() + CIfrOpHeader.__init__(self, self.__Version.Header, EFI_IFR_VERSION_OP) + self.SetLineNo(LineNo) + + def GetHeader(self): + return self.__Version.Header + + +class CIfrLength(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__Length = EFI_IFR_LENGTH() + CIfrOpHeader.__init__(self, self.__Length.Header, EFI_IFR_LENGTH_OP) + self.SetLineNo(LineNo) + + +class CIfrBitWiseNot(CIfrObj, CIfrOpHeader): + + def __init__(self, LineNo): + self.__BitWiseNot = EFI_IFR_BITWISE_NOT() + CIfrOpHeader.__init__(self, self.__BitWiseNot.Header, + EFI_IFR_BITWISE_NOT_OP) + self.SetLineNo(LineNo) + + +class ExpressionInfo(): + + def __init__(self): + self.RootLevel = 0 + self.ExpOpCount = 0 \ No newline at end of file diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 new file mode 100644 index 0000000000..89c9e67b59 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 @@ -0,0 +1,1887 @@ +grammar VfrSyntax; +options { + language=Python; +} +@header{ + +from VfrCompiler.CommonCtypes import * +from VfrCompiler.VfrFormPkg import * +from VfrCompiler.VfrUtility import * +from VfrCompiler.VfrTree import * +} + +vfrProgram + : (vfrPragmaPackDefinition | vfrDataStructDefinition | vfrDataUnionDefinition)* vfrFormSetDefinition + ; + +pragmaPackShowDef + : 'show' + ; + +pragmaPackStackDef + : ('push' | 'pop') (',' StringIdentifier)? (',' Number)? + ; + +pragmaPackNumber + : Number? + ; + +vfrPragmaPackDefinition + : '#pragma' 'pack' '(' + ( pragmaPackShowDef + | pragmaPackStackDef + | pragmaPackNumber + )? + ')' + ; + +vfrDataStructDefinition + : (TypeDef)? Struct NonNvDataMap? N1=StringIdentifier? '{' vfrDataStructFields[False] '}' N2=StringIdentifier? ';' + ; + +vfrDataUnionDefinition + : (TypeDef)? Union NonNvDataMap? N1=StringIdentifier? '{' vfrDataStructFields[True]'}' N2=StringIdentifier? ';' + ; + +vfrDataStructFields[FieldInUnion] + : + ( dataStructField64[FieldInUnion] + | dataStructField32[FieldInUnion] + | dataStructField16[FieldInUnion] + | dataStructField8[FieldInUnion] + | dataStructFieldBool[FieldInUnion] + | dataStructFieldString[FieldInUnion] + | dataStructFieldDate[FieldInUnion] + | dataStructFieldTime[FieldInUnion] + | dataStructFieldRef[FieldInUnion] + | dataStructFieldUser[FieldInUnion] + | dataStructBitField64[FieldInUnion] + | dataStructBitField32[FieldInUnion] + | dataStructBitField16[FieldInUnion] + | dataStructBitField8[FieldInUnion] + )* + ; + +dataStructField64[FieldInUnion] + : 'UINT64' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructField32[FieldInUnion] + : 'UINT32' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructField16[FieldInUnion] + : 'UINT16' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructField8[FieldInUnion] + : 'UINT8' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldBool[FieldInUnion] + : 'BOOLEAN' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldString[FieldInUnion] + : 'EFI_STRING_ID' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldDate[FieldInUnion] + : 'EFI_HII_DATE' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldTime[FieldInUnion] + : 'EFI_HII_TIME' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldRef[FieldInUnion] + : 'EFI_HII_REF' N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructFieldUser[FieldInUnion] + : T=StringIdentifier N=StringIdentifier ('[' Number ']')? ';' + ; + +dataStructBitField64[FieldInUnion] + : D='UINT64' N=StringIdentifier? ':' Number ';' + ; +dataStructBitField32[FieldInUnion] + : D='UINT32' N=StringIdentifier? ':' Number ';' + ; +dataStructBitField16[FieldInUnion] + : D='UINT16' N=StringIdentifier? ':' Number ';' + ; +dataStructBitField8[FieldInUnion] + : D='UINT8' N=StringIdentifier? ':' Number ';' + ; + +// 2.4 VFR FormSet Definition +vfrFormSetDefinition +locals[Node=VfrTreeNode(EFI_IFR_FORM_SET_OP)] + : 'formset' + 'guid' '=' guidDefinition ',' + 'title' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('classguid' '=' classguidDefinition[localctx.Node] ',')? + ('class' '=' classDefinition ',')? + ('subclass' '=' subclassDefinition ',')? + vfrFormSetList[localctx.Node] + 'endformset' ';' + ; + +classguidDefinition[Node] +locals[GuidList=[]] + : guidDefinition ('|' guidDefinition)? ('|' guidDefinition)?('|' guidDefinition)? + ; + +classDefinition +locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)] + : validClassNames ('|' validClassNames)* + ; + +validClassNames +locals[ClassName=0] + : ClassNonDevice + | ClassDiskDevice + | ClassVideoDevice + | ClassNetworkDevice + | ClassInputDevice + | ClassOnBoardDevice + | ClassOtherDevice + | Number + ; + +subclassDefinition +locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)] + : SubclassSetupApplication + | SubclassGeneralApplication + | SubclassFrontPage + | SubclassSingleUse + | Number + ; + + +vfrFormSetList[Node] + : (vfrFormSet)* + ; + +//2.5 VFR FormSet List Definition +vfrFormSet +locals[Node=None] + : + ( vfrFormDefinition + | vfrFormMapDefinition + | vfrStatementImage + | vfrStatementVarStoreLinear + | vfrStatementVarStoreEfi + | vfrStatementVarStoreNameValue + | vfrStatementDefaultStore + | vfrStatementDisableIfFormSet + | vfrStatementSuppressIfFormSet + | vfrStatementExtension + ) + ; + + +//2.6 VFR Default Stores Definition +vfrStatementDefaultStore +locals[Node=VfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)] + : 'defaultstore' N=StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' S=Number ')' + (',' 'attribute' '=' A=Number)? ';' + ; + +//2.7 VFR Variable Store Definition +vfrStatementVarStoreLinear +locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_OP)] + : 'varstore' + ( TN=StringIdentifier ',' + | 'UINT8' ',' + | 'UINT16' ',' + | 'UINT32' ',' + | 'UINT64' ',' + | 'EFI_HII_DATE' ',' + | 'EFI_HII_TIME' ',' + | 'EFI_HII_REF' ',' + ) + ('varid' '=' ID=Number ',')? + 'name' '=' SN=StringIdentifier ',' + 'guid' '=' guidDefinition ';' + ; + +vfrStatementVarStoreEfi +locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)] + : 'efivarstore' + ( TN=StringIdentifier ',' + | 'UINT8' ',' + | 'UINT16' ',' + | 'UINT32' ',' + | 'UINT64' ',' + | 'EFI_HII_DATE' ',' + | 'EFI_HII_TIME' ',' + | 'EFI_HII_REF' ',' + ) + ('varid' '=' ID=Number ',')? + 'attribute' '=' vfrVarStoreEfiAttr ('|' vfrVarStoreEfiAttr)* ',' + ( 'name' '=' SN=StringIdentifier ',' + | 'name' '=' 'STRING_TOKEN' '(' VN=Number ')' ',' 'varsize' '=' N=Number ',' + ) + 'guid' '=' guidDefinition ';' + ; + +vfrVarStoreEfiAttr +locals[Attr=0] + : Number; + +vfrStatementVarStoreNameValue +locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)] + : 'namevaluevarstore' SN=StringIdentifier ',' + ('varid' '=' ID=Number ',')? + ('name' '=' 'STRING_TOKEN' '(' Number ')' ',')+ + 'guid' '=' guidDefinition ';' + ; + +vfrStatementDisableIfFormSet +locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)] + : 'disableif' vfrStatementExpression ';' + vfrFormSetList[localctx.Node] + 'endif' ';' + ; + +vfrStatementSuppressIfFormSet +locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)] + : 'suppressif' vfrStatementExpression ';' + vfrFormSetList[localctx.Node] + 'endif' ';' + ; + +guidSubDefinition[Guid] + : Number ',' Number ',' Number ',' Number ',' + Number ',' Number ',' Number ',' Number + ; + +guidDefinition +locals[Node=VfrTreeNode(), Guid=EFI_GUID()] + : '{' + Number ',' Number ',' Number ',' + ( '{' guidSubDefinition[localctx.Guid] '}' + | guidSubDefinition[localctx.Guid] + ) + '}' + ; + +getStringId +locals[StringId=''] + : 'STRING_TOKEN' '(' Number ')' + ; + +vfrQuestionHeader[OpObj, QType] + : vfrQuestionBaseInfo[OpObj, QType] + vfrStatementHeader[OpObj] + ; + +vfrQuestionBaseInfo[OpObj, QType] +locals[BaseInfo=EFI_VARSTORE_INFO(), QId=EFI_QUESTION_ID_INVALID, CheckFlag=True] + : ('name' '=' QN=StringIdentifier ',')? + ('varid' '=' vfrStorageVarId[localctx.BaseInfo, localctx.CheckFlag] ',')? + ('questionid' '=' ID=Number ',')? + ; + +vfrStatementHeader[OpObj] + : 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' + ; + +questionheaderFlagsField +locals[QHFlag=0] + : ReadOnlyFlag + | InteractiveFlag + | ResetRequiredFlag + | RestStyleFlag + | ReconnectRequiredFlag + | O=OptionOnlyFlag + | N=NVAccessFlag + | L=LateCheckFlag + ; +//2.10.5 +vfrStorageVarId[BaseInfo, CheckFlag] +locals[VarIdStr=''] + : (SN1=StringIdentifier '[' I=Number ']') # vfrStorageVarIdRule1 + | (SN2=StringIdentifier ('.' arrayName)* ) # vfrStorageVarIdRule2 + ; + +vfrConstantValueField +locals[Value=EFI_IFR_TYPE_VALUE(), ValueList=[], ListType=False] + : ('-')? Number + | 'TRUE' + | 'FALSE' + | 'ONE' + | 'ONES' + | 'ZERO' + | Number ':' Number ':' Number + | Number '/' Number '/' Number + | Number ';' Number ';' guidDefinition ';' 'STRING_TOKEN' '(' Number ')' + | 'STRING_TOKEN' '(' Number ')' + | '{' Number (',' Number)* '}' + ; + +vfrImageTag +locals[Node=VfrTreeNode(EFI_IFR_IMAGE_OP)] + : 'image' '=' 'IMAGE_TOKEN' '(' Number ')' + ; + +vfrLockedTag +locals[Node=VfrTreeNode(EFI_IFR_LOCKED_OP)] + : 'locked' + ; + +vfrStatementStatTag +locals[Node] + : vfrImageTag | vfrLockedTag + ; + +vfrStatementStatTagList[Node] + : vfrStatementStatTag (',' vfrStatementStatTag)* + ; + +vfrFormDefinition +locals[Node=VfrTreeNode(EFI_IFR_FORM_OP)] + : 'form' 'formid' '=' Number ',' + 'title' '=' 'STRING_TOKEN' '(' Number ')' ';' + (vfrForm)* + 'endform' ';' + ; + +vfrForm +locals[Node] + : + ( vfrStatementImage + | vfrStatementLocked + | vfrStatementRules + | vfrStatementDefault + | vfrStatementStat + | vfrStatementQuestions + | vfrStatementConditional + | vfrStatementLabel + | vfrStatementBanner + | vfrStatementInvalid + | vfrStatementExtension + | vfrStatementModal + | vfrStatementRefreshEvent ';' + ) + ; + +vfrFormMapDefinition +locals[Node=VfrTreeNode(EFI_IFR_FORM_MAP_OP)] + : 'formmap' 'formid' '=' S1=Number ',' + ( 'maptitle' '=' 'STRING_TOKEN' '(' Number ')' ';' + 'mapguid' '=' guidDefinition ';' + )* + (vfrForm)* + 'endform' ';' + ; + +vfrStatementImage +locals[Node] + : vfrImageTag ';' + ; + +vfrStatementLocked +locals[Node] + : vfrLockedTag ';' + ; + +vfrStatementRules +locals[Node=VfrTreeNode(EFI_IFR_RULE_OP)] + : 'rule' StringIdentifier ',' + vfrStatementExpression + 'endrule' ';' + ; + +vfrStatementStat +locals[Node] + : vfrStatementSubTitle + | vfrStatementStaticText + | vfrStatementCrossReference + ; + +vfrStatementSubTitle +locals[Node=VfrTreeNode(EFI_IFR_SUBTITLE_OP), OpObj=CIfrSubtitle()] + : 'subtitle' + + 'text' '=' 'STRING_TOKEN' '(' Number ')' + (',' 'flags' '=' vfrSubtitleFlags)? + ( (',' vfrStatementStatTagList[localctx.Node])? ';' + | + (',' vfrStatementStatTagList[localctx.Node])? + (',' (vfrStatementSubTitleComponent)* )? + 'endsubtitle' ';' + ) + ; + +vfrStatementSubTitleComponent +locals[Node] + : vfrStatementStat | vfrStatementQuestions + ; + +vfrSubtitleFlags +locals[SubFlags=0] + : subtitleFlagsField ('|' subtitleFlagsField)* + ; +subtitleFlagsField +locals[Flag=0] + : Number | 'HORIZONTAL' + ; + +vfrStatementStaticText +locals[Node=VfrTreeNode(EFI_IFR_TEXT_OP)] + : 'text' + 'help' '=' 'STRING_TOKEN' '(' S1=Number ')' ',' + 'text' '=' 'STRING_TOKEN' '(' S2=Number ')' + (',' 'text' '=' 'STRING_TOKEN' '(' S3=Number ')')? + (',' F='flags' '=' staticTextFlagsField ('|' staticTextFlagsField)* ',' 'key' '=' S4=Number)? + (',' vfrStatementStatTagList[localctx.Node])? ';' + ; + +staticTextFlagsField +locals[Flag=0] + : N=Number | questionheaderFlagsField + ; + +vfrStatementCrossReference +locals[Node] + : vfrStatementGoto | vfrStatementResetButton + ; + +vfrStatementGoto +locals[Node=VfrTreeNode(EFI_IFR_REF_OP), OpObj=None, OHObj=None, QType=EFI_QUESION_TYPE.QUESTION_REF] + : 'goto' + ( ( DevicePath '=' 'STRING_TOKEN' '(' Number ')' ',' + FormSetGuid '=' guidDefinition ',' + FormId '=' Number ',' + Question '=' Number ',' + ) + | + ( FormSetGuid '=' guidDefinition ',' + FormId '=' Number ',' + Question '=' Number ',' + ) + | + ( FormId '=' Number ',' + Question '=' (QN=StringIdentifier ',' | Number ',') + ) + | + ( Number ',' ) + )? + vfrQuestionHeader[localctx.OpObj, localctx.QType] + (',' 'flags' '=' vfrGotoFlags[localctx.OpObj])? + (',' 'key' '=' Number)? + (',' vfrStatementQuestionOptionList[localctx.Node])? ';' + ; + +vfrGotoFlags[Obj] +locals[GotoFlags=0] + : gotoFlagsField('|' gotoFlagsField)* + ; + +gotoFlagsField +locals[Flag=0] + : N=Number | questionheaderFlagsField + ; + +vfrStatementResetButton +locals[Node=VfrTreeNode(EFI_IFR_RESET_BUTTON_OP), OpObj=CIfrResetButton()] + : 'resetbutton' + 'defaultstore' '=' N=StringIdentifier ',' + vfrStatementHeader[localctx.OpObj] ',' + (vfrStatementStatTagList[localctx.Node] ',')? + 'endresetbutton' ';' + ; + +vfrStatementQuestions +locals[Node] + : vfrStatementBooleanType + | vfrStatementDate + | vfrStatementNumericType + | vfrStatementStringType + | vfrStatementOrderedList + | vfrStatementTime + ; + +vfrStatementQuestionTag +locals[Node] + : vfrStatementStatTag ',' + | vfrStatementInconsistentIf + | vfrStatementNoSubmitIf + | vfrStatementDisableIfQuest + | vfrStatementRefresh + | vfrStatementVarstoreDevice + | vfrStatementExtension + | vfrStatementRefreshEvent + | vfrStatementWarningIf + ; + +vfrStatementInconsistentIf +locals[Node=VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)] + : 'inconsistentif' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression + 'endif' (';')? + ; + +vfrStatementNoSubmitIf +locals[Node=VfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)] + : 'nosubmitif' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression + 'endif' (';')? + ; + +vfrStatementDisableIfQuest +locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)] + : 'disableif' vfrStatementExpression ';' + vfrStatementQuestionOptionList[localctx.Node] + 'endif' (';')? + ; + +vfrStatementRefresh +locals[Node=VfrTreeNode(EFI_IFR_REFRESH_OP)] + : 'refresh' 'interval' '=' Number + ; + +vfrStatementVarstoreDevice +locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)] + : 'varstoredevice' '=' 'STRING_TOKEN' '(' Number ')' ',' + ; + +vfrStatementRefreshEvent +locals[Node=VfrTreeNode(EFI_IFR_REFRESH_ID_OP)] + : 'refreshguid' '=' guidDefinition ',' + ; + +vfrStatementWarningIf +locals[Node=VfrTreeNode(EFI_IFR_WARNING_IF_OP)] + : 'warningif' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('timeout' '=' Number ',')? + vfrStatementExpression + 'endif' (';')? + ; + +vfrStatementQuestionTagList[Node] + : (vfrStatementQuestionTag)* + ; + +vfrStatementQuestionOptionTag +locals[Node] + : vfrStatementSuppressIfQuest + | vfrStatementGrayOutIfQuest + | vfrStatementValue + | vfrStatementDefault + | vfrStatementOptions + | vfrStatementRead + | vfrStatementWrite + ; + +flagsField + : Number + | InteractiveFlag + | ManufacturingFlag + | DefaultFlag + | ResetRequiredFlag + | ReconnectRequiredFlag + | N=NVAccessFlag + | L=LateCheckFlag + ; + +vfrStatementSuppressIfQuest +locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)] + : 'suppressif' vfrStatementExpression ';' + ('flags' '=' flagsField ('|' flagsField )* ',')? + vfrStatementQuestionOptionList[localctx.Node] + 'endif' (';')? + ; + +vfrStatementGrayOutIfQuest +locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)] + : 'grayoutif' vfrStatementExpression ';' + ('flags' '=' flagsField ('|' flagsField )* ',')? + vfrStatementQuestionOptionList[localctx.Node] + 'endif' (';')? + ; + + +vfrStatementDefault +locals[Node=VfrTreeNode(EFI_IFR_DEFAULT_OP)] + : D='default' + ( ( vfrStatementValue ',' + | '=' vfrConstantValueField ',' + ) + ( 'defaultstore' '=' SN=StringIdentifier ',' + )? + ) + ; + +vfrStatementValue +locals[Node=VfrTreeNode(EFI_IFR_VALUE_OP)] + : 'value' '=' vfrStatementExpression + ; + +vfrStatementOptions +locals[Node] + : vfrStatementOneOfOption + ; + +vfrStatementOneOfOption +locals[Node=VfrTreeNode(EFI_IFR_ONE_OF_OPTION_OP)] + : 'option' + 'text' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'value' '=' vfrConstantValueField ',' + F='flags' '=' vfrOneOfOptionFlags (',' 'key' '=' KN=Number) ? (',' vfrImageTag)* ';' + ; + +vfrOneOfOptionFlags +locals[HFlags=0, LFlags=0] + : oneofoptionFlagsField ('|' oneofoptionFlagsField)*; + +oneofoptionFlagsField + locals[HFlag=0, LFlag=0] + : Number + | OptionDefault + | OptionDefaultMfg + | InteractiveFlag + | ResetRequiredFlag + | RestStyleFlag + | ReconnectRequiredFlag + | ManufacturingFlag + | DefaultFlag + | A=NVAccessFlag + | L=LateCheckFlag + ; + +vfrStatementRead +locals[Node=VfrTreeNode(EFI_IFR_READ_OP)] + : 'read' vfrStatementExpression ';' + ; + +vfrStatementWrite +locals[Node=VfrTreeNode(EFI_IFR_WRITE_OP)] + : 'write' vfrStatementExpression ';' + ; + +vfrStatementQuestionOptionList[Node] + : (vfrStatementQuestionOption)* + ; + + + +vfrStatementQuestionOption +locals[Node] + : vfrStatementQuestionTag | vfrStatementQuestionOptionTag + ; + +vfrStatementBooleanType +locals[Node] + : vfrStatementCheckBox | vfrStatementAction + ; + +vfrStatementCheckBox +locals[Node=VfrTreeNode(EFI_IFR_CHECKBOX_OP), OpObj=CIfrCheckBox(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : L='checkbox' + vfrQuestionBaseInfo[localctx.OpObj, localctx.QType] + vfrStatementHeader[localctx.OpObj] ',' + (F='flags' '=' vfrCheckBoxFlags ',')? + ('key' '=' Number ',')? + vfrStatementQuestionOptionList[localctx.Node] + 'endcheckbox' ';' + ; + +vfrCheckBoxFlags +locals[LFlags=0, HFlags=0] + : checkboxFlagsField ('|' checkboxFlagsField)* + ; + +checkboxFlagsField +locals[LFlag=0, HFlag=0] + : Number + | D='DEFAULT' + | M='MANUFACTURING' + | 'CHECKBOX_DEFAULT' + | 'CHECKBOX_DEFAULT_MFG' + | questionheaderFlagsField + ; + +vfrStatementAction +locals[Node=VfrTreeNode(EFI_IFR_ACTION_OP),OpObj=CIfrAction(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'action' + vfrQuestionHeader[localctx.OpObj, localctx.QType] ',' + ('flags' '=' vfrActionFlags ',')? + 'config' '=' 'STRING_TOKEN' '(' Number ')' ',' + vfrStatementQuestionTagList[localctx.Node] + 'endaction' ';' + ; + +vfrActionFlags +locals[HFlags=0] + : actionFlagsField ('|' actionFlagsField)* + ; +actionFlagsField +locals[HFlag=0] + : N=Number | questionheaderFlagsField + ; + +vfrStatementNumericType +locals[Node] + : vfrStatementNumeric | vfrStatementOneOf + ; + +vfrStatementNumeric +locals[Node=VfrTreeNode(EFI_IFR_NUMERIC_OP), OpObj=CIfrNumeric(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'numeric' + vfrQuestionBaseInfo[localctx.OpObj, localctx.QType] + vfrStatementHeader[localctx.OpObj] ',' + (F='flags' '=' vfrNumericFlags ',')? + ('key' '=' Number ',')? + vfrSetMinMaxStep[localctx.OpObj] + vfrStatementQuestionOptionList[localctx.Node] + 'endnumeric' ';' + ; + +vfrSetMinMaxStep[OpObj] // CIfrMinMaxStepData + : 'minimum' '=' (N1='-')? I=Number ',' + 'maximum' '=' (N2='-')? A=Number ',' + ('step' '=' S=Number ',')? + ; + +vfrNumericFlags +locals[HFlags=0, LFlags=0,IsDisplaySpecified=False] + : numericFlagsField ('|' numericFlagsField)* + ; + +numericFlagsField +locals[HFlag=0,IsSetType=False,IsDisplaySpecified=False] + : N=Number + | 'NUMERIC_SIZE_1' + | 'NUMERIC_SIZE_2' + | 'NUMERIC_SIZE_4' + | 'NUMERIC_SIZE_8' + | 'DISPLAY_INT_DEC' + | 'DISPLAY_UINT_DEC' + | 'DISPLAY_UINT_HEX' + | questionheaderFlagsField + ; + +vfrStatementOneOf +locals[Node=VfrTreeNode(EFI_IFR_ONE_OF_OP), OpObj=CIfrOneOf(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'oneof' + vfrQuestionBaseInfo[localctx.OpObj, localctx.QType] + vfrStatementHeader[localctx.OpObj] ',' + (F='flags' '=' vfrOneofFlagsField ',')? + (vfrSetMinMaxStep[localctx.OpObj])? + vfrStatementQuestionOptionList[localctx.Node] + 'endoneof' ';' + ; + +vfrOneofFlagsField +locals[HFlags=0, LFlags=0] + : numericFlagsField ('|' numericFlagsField)* + ; + +vfrStatementStringType +locals[Node] + : vfrStatementString | vfrStatementPassword + ; + +vfrStatementString +locals[Node=VfrTreeNode(EFI_IFR_STRING_OP), OpObj=CIfrString(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'string' + vfrQuestionHeader[localctx.OpObj, localctx.QType] ',' + (F='flags' '=' vfrStringFlagsField ',')? + ('key' '=' Number ',')? + Min='minsize' '=' Number ',' + Max='maxsize' '=' Number ',' + vfrStatementQuestionOptionList[localctx.Node] + 'endstring' ';' + ; + +vfrStringFlagsField +locals[HFlags=0, LFlags=0] + : stringFlagsField ('|' stringFlagsField)* + ; + +stringFlagsField +locals[HFlag=0, LFlag=0] + : N=Number + | 'MULTI_LINE' + | questionheaderFlagsField + ; + +vfrStatementPassword +locals[Node=VfrTreeNode(EFI_IFR_PASSWORD_OP), OpObj=CIfrPassword(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'password' + vfrQuestionHeader[localctx.OpObj, localctx.QType]',' + (F='flags' '=' vfrPasswordFlagsField ',')? + ('key' '=' Number ',')? + Min='minsize' '=' Number ',' + Max='maxsize' '=' Number ',' + ('encoding' '=' Number ',')? + vfrStatementQuestionOptionList[localctx.Node] + 'endpassword' ';' + ; + +vfrPasswordFlagsField +locals[HFlags=0] + : passwordFlagsField('|' passwordFlagsField)* + ; + +passwordFlagsField +locals[HFlag=0] + : Number + | questionheaderFlagsField + ; + +vfrStatementOrderedList +locals[Node=VfrTreeNode(EFI_IFR_ORDERED_LIST_OP), OpObj=CIfrOrderedList(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL] + : 'orderedlist' + vfrQuestionHeader[localctx.OpObj, localctx.QType] ',' + (M='maxcontainers' '=' Number ',')? + (F='flags' '=' vfrOrderedListFlags ',')? + vfrStatementQuestionOptionList[localctx.Node] + 'endlist' ';' + ; + +vfrOrderedListFlags +locals[HFlags=0, LFlags=0] + : orderedlistFlagsField ('|' orderedlistFlagsField)* + ; + +orderedlistFlagsField +locals[HFlag=0, LFlag=0] + : Number + | 'UNIQUE' + | 'NOEMPTY' + | questionheaderFlagsField + ; + +vfrStatementDate +locals[Node=VfrTreeNode(EFI_IFR_DATE_OP), OpObj=CIfrDate(), QType=EFI_QUESION_TYPE.QUESTION_DATE, Val=EFI_IFR_TYPE_VALUE()] + : 'date' + ( ( vfrQuestionHeader[localctx.OpObj, localctx.QType] ',' + (F1='flags' '=' vfrDateFlags ',')? + vfrStatementQuestionOptionList[localctx.Node] + ) + | + ( 'year' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxDateStepDefault[localctx.Val.date, 0] + 'month' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxDateStepDefault[localctx.Val.date, 1] + 'day' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxDateStepDefault[localctx.Val.date, 2] + (F2='flags' '=' vfrDateFlags ',')? + (vfrStatementInconsistentIf)* + ) + ) + 'enddate' ';' + ; + +minMaxDateStepDefault[Date, KeyValue] + : 'minimum' '=' Number ',' + 'maximum' '=' Number ',' + ('step' '=' Number ',')? + ('default' '=' N=Number ',')? + ; + +vfrDateFlags +locals[LFlags=0] + : dateFlagsField ('|' dateFlagsField)* + ; +dateFlagsField +locals[LFlag=0] + : Number + | 'YEAR_SUPPRESS' + | 'MONTH_SUPPRESS' + | 'DAY_SUPPRESS' + | 'STORAGE_NORMAL' + | 'STORAGE_TIME' + | 'STORAGE_WAKEUP' + ; + +vfrStatementTime +locals[Node=VfrTreeNode(EFI_IFR_TIME_OP), OpObj=CIfrTime(), QType=EFI_QUESION_TYPE.QUESTION_TIME, Val=EFI_IFR_TYPE_VALUE()] + : 'time' + ( ( vfrQuestionHeader[localctx.OpObj, localctx.QType] ',' + (F1='flags' '=' vfrTimeFlags ',')? + vfrStatementQuestionOptionList[localctx.Node] + ) + | + ( + 'hour' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxTimeStepDefault[localctx.Val.time, 0] + 'minute' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxTimeStepDefault[localctx.Val.time, 1] + 'second' 'varid' '=' StringIdentifier '.' StringIdentifier ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + minMaxTimeStepDefault[localctx.Val.time, 2] + (F2='flags' '=' vfrTimeFlags ',')? + (vfrStatementInconsistentIf)* + ) + ) + 'endtime' ';' + ; + +minMaxTimeStepDefault[Time, KeyValue] + : 'minimum' '=' Number ',' + 'maximum' '=' Number ',' + ('step' '=' Number ',')? + ('default' '=' N=Number ',')? + ; + +vfrTimeFlags +locals[LFlags=0] + : timeFlagsField ('|' timeFlagsField)* + ; + +timeFlagsField +locals[LFlag=0] + : Number + | 'HOUR_SUPPRESS' + | 'MINUTE_SUPPRESS' + | 'SECOND_SUPPRESS' + | 'STORAGE_NORMAL' + | 'STORAGE_TIME' + | 'STORAGE_WAKEUP' + ; + +vfrStatementConditional +locals[Node] + : vfrStatementDisableIfStat + | vfrStatementSuppressIfStat //enhance to be compatible for framework endif + | vfrStatementGrayOutIfStat + | vfrStatementInconsistentIfStat //to be compatible for framework + ; + +// new seems to be the same as the old, why new? +vfrStatementConditionalNew +locals[Node] + : vfrStatementDisableIfStat + vfrStatementSuppressIfStatNew + vfrStatementGrayOutIfStatNew + vfrStatementInconsistentIfStat //to be compatible for framework + ; + +vfrStatementSuppressIfStat +locals[Node] + : vfrStatementSuppressIfStatNew + ; + +vfrStatementGrayOutIfStat +locals[Node] + : vfrStatementGrayOutIfStatNew + ; + +vfrStatementStatList +locals[Node] + : vfrStatementStat + | vfrStatementQuestions + | vfrStatementConditional + | vfrStatementLabel + | vfrStatementExtension + | vfrStatementInvalid + ; + +vfrStatementStatListOld + : vfrStatementStat + | vfrStatementQuestions + | vfrStatementLabel + // Just for framework vfr compatibility + | vfrStatementInvalid + ; + +vfrStatementDisableIfStat +locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)] + : 'disableif' vfrStatementExpression ';' + (vfrStatementStatList)* + 'endif' ';' + ; + + +// Compatible for framework vfr file +// +vfrStatementgrayoutIfSuppressIf + : 'suppressif' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression ';' + ; + +vfrStatementsuppressIfGrayOutIf + : 'grayoutif' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression ';' + ; + +vfrStatementSuppressIfStatNew +locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)] + : 'suppressif' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression ';' + (vfrStatementStatList)* + 'endif' ';' + ; + +vfrStatementGrayOutIfStatNew +locals[Node=VfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)] + : 'grayoutif' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression ';' + (vfrStatementStatList)* + 'endif' ';' + ; + +vfrStatementInconsistentIfStat +locals[Node=VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)] + : 'inconsistentif' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('flags' '=' flagsField ('|' flagsField)* ',')? + vfrStatementExpression + 'endif' ';' + ; + +vfrStatementInvalid // for compatibility + : vfrStatementInvalidHidden + | vfrStatementInvalidInventory + | vfrStatementInvalidSaveRestoreDefaults + ; + +vfrStatementInvalidHidden + : 'hidden' + 'value' '=' Number ',' + 'key' '=' Number ';' + ; + +vfrStatementInvalidInventory + : 'inventory' + 'help' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'text' '=' 'STRING_TOKEN' '(' Number ')' ',' + ('text' '=' 'STRING_TOKEN' '(' Number ')')? + ';' + ; + +vfrStatementInvalidSaveRestoreDefaults + : ( 'save' + | 'restore' + ) + 'defaults' ',' + 'formid' '=' Number ',' + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ',' + 'help' '=' 'STRING_TOKEN' '(' Number ')' + (',' 'flags' '=' flagsField ('|' flagsField)*)? + (',' 'key' '=' Number)? + ';' + ; +vfrStatementLabel +locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)] + : 'label' Number ';' + ; + +vfrStatementBanner // Is TimeOut needed +locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)] + : 'banner' (',')? + 'title' '=' 'STRING_TOKEN' '(' Number ')' ',' + ( ( 'line' Number ',' + 'align' ('left' | 'center' | 'right') ';' + ) + | + ( 'timeout' '=' Number ';' + ) + ) + ; + +vfrStatementExtension +locals[Node=VfrTreeNode(EFI_IFR_GUID_OP), DataBuff, Size=0, TypeName='', TypeSize=0, IsStruct=False, ArrayNum=0] + : 'guidop' + 'guid' '=' guidDefinition + ( ',' D='datatype' '=' + ( 'UINT64' ('[' Number ']')? + | 'UINT32' ('[' Number ']')? + | 'UINT16' ('[' Number ']')? + | 'UINT8' ('[' Number ']')? + | 'BOOLEAN' ('[' Number ']')? + | 'EFI_STRING_ID' ('[' Number ']')? + | 'EFI_HII_DATE' ('[' Number ']')? + | 'EFI_HII_TIME' ('[' Number ']')? + | 'EFI_HII_REF' ('[' Number ']')? + | StringIdentifier ('[' Number ']')? + ) + (vfrExtensionData[localctx.DataBuff])* + )? + ( + ',' (vfrStatementExtension)* + 'endguidop' + )? + ';' + ; + + +vfrExtensionData[DataBuff] +locals[IsStruct] + : ',' 'data' ('[' Number ']')? + ( '.' arrayName)* '=' N=Number + ; + + +vfrStatementModal +locals[Node] + : vfrModalTag ';' + ; + +vfrModalTag +locals[Node=VfrTreeNode(EFI_IFR_MODAL_TAG_OP)] + : 'modal' + ; + +vfrStatementExpression +locals[ExpInfo=ExpressionInfo()] + : andTerm[localctx.ExpInfo] ('OR' andTerm[localctx.ExpInfo])* + ; + +vfrStatementExpressionSub +locals[ExpInfo=ExpressionInfo()] + : andTerm[localctx.ExpInfo] ('OR' andTerm[localctx.ExpInfo])* + ; + +andTerm[ExpInfo] +locals[CIfrAndList=[]] + : bitwiseorTerm[ExpInfo] ('AND' bitwiseorTerm[ExpInfo])* + ; + +bitwiseorTerm[ExpInfo] +locals[CIfrBitWiseOrList=[]] + : bitwiseandTerm[ExpInfo] ('|' bitwiseandTerm[ExpInfo])* + ; + + +bitwiseandTerm[ExpInfo] +locals[CIfrBitWiseAndList=[]] + : equalTerm[ExpInfo] ('&' equalTerm[ExpInfo])* + ; + + +equalTerm[ExpInfo] +locals[CIfrEqualList=[], CIfrNotEqualList=[]] + : compareTerm[localctx.ExpInfo] + (equalTermSupplementary[localctx.CIfrEqualList, localctx.CIfrNotEqualList, ExpInfo])* + ; + + +equalTermSupplementary[CIfrEqualList, CIfrNotEqualList, ExpInfo] + : ('==' compareTerm[ExpInfo]) # equalTermEqualRule + | + ('!=' compareTerm[ExpInfo]) # equalTermNotEqualRule + ; + +compareTerm[ExpInfo] +locals[CIfrLessThanList=[], CIfrLessEqualList=[], CIfrGreaterThanList=[], CIfrGreaterEqualList=[]] + : shiftTerm[ExpInfo] + (compareTermSupplementary[localctx.CIfrLessThanList, localctx.CIfrLessEqualList, localctx.CIfrGreaterThanList, localctx.CIfrGreaterEqualList, ExpInfo])* + ; + +compareTermSupplementary[CIfrLessThanList, CIfrLessEqualList, CIfrGreaterThanList, CIfrGreaterEqualList, ExpInfo] + : ('<' shiftTerm[ExpInfo]) # compareTermLessRule + | + ('<=' shiftTerm[ExpInfo]) # compareTermLessEqualRule + | + ('>' shiftTerm[ExpInfo]) # compareTermGreaterRule + | + ('>=' shiftTerm[ExpInfo]) # compareTermGreaterEqualRule + ; + +shiftTerm[ExpInfo] +locals[CIfrShiftLeftList=[], CIfrShiftRightList=[]] + : addMinusTerm[ExpInfo] + (shiftTermSupplementary[localctx.CIfrShiftLeftList, localctx.CIfrShiftRightList, ExpInfo])* + ; + +shiftTermSupplementary[CIfrShiftLeftList, CIfrShiftRightList, ExpInfo] + : ('<<' addMinusTerm[ExpInfo]) # shiftTermLeft + | + ('>>' addMinusTerm[ExpInfo]) # shiftTermRight + ; + +addMinusTerm[ExpInfo] +locals[CIfrAddList=[], CIfrSubtractList=[]] + : multdivmodTerm[ExpInfo] + (addMinusTermSupplementary[localctx.CIfrAddList, localctx.CIfrSubtractList, ExpInfo])* + ; + +addMinusTermSupplementary[CIfrAddList, CIfrSubtractList, ExpInfo] + : ('+' multdivmodTerm[ExpInfo]) # addMinusTermpAdd + | + ('-' multdivmodTerm[ExpInfo]) # addMinusTermSubtract + ; + +multdivmodTerm[ExpInfo] +locals[CIfrMultiplyList=[], CIfrDivideList=[], CIfrModuloList=[]] + : castTerm[ExpInfo] + (multdivmodTermSupplementary[localctx.CIfrMultiplyList, localctx.CIfrDivideList, localctx.CIfrModuloList, ExpInfo])* + ; + +multdivmodTermSupplementary[CIfrMultiplyList, CIfrDivideList, CIfrModuloList, ExpInfo] + : ('*' castTerm[ExpInfo]) # multdivmodTermMul + | + ('/' castTerm[ExpInfo]) # multdivmodTermDiv + | + ('%' castTerm[ExpInfo]) # multdivmodTermModulo + ; + +castTerm[ExpInfo] +locals[TBObj=None, TUObj=None] + : ( '(' + ( 'BOOLEAN' + | 'UINT64' + | 'UINT32' + | 'UINT16' + | 'UINT8' + ) + ')' + )* + atomTerm[ExpInfo] + ; + +atomTerm[ExpInfo] + : vfrExpressionCatenate[ExpInfo] + | vfrExpressionMatch[ExpInfo] + | vfrExpressionMatch2[ExpInfo] + | vfrExpressionParen[ExpInfo] + | vfrExpressionBuildInFunction[ExpInfo] + | vfrExpressionConstant[ExpInfo] + | vfrExpressionUnaryOp[ExpInfo] + | vfrExpressionTernaryOp[ExpInfo] + | vfrExpressionMap[ExpInfo] + | ('NOT' atomTerm[ExpInfo]) + | vfrExpressionMatch2[ExpInfo] + ; + +vfrExpressionCatenate[ExpInfo] +locals[CObj=None] + : 'catenate' + '(' vfrStatementExpressionSub ',' vfrStatementExpressionSub ')' + ; + +vfrExpressionMatch[ExpInfo] +locals[MObj=None] + : 'match' + '(' vfrStatementExpressionSub ',' vfrStatementExpressionSub ')' + ; + +vfrExpressionMatch2[ExpInfo] +locals[M2Obj=None] + : 'match2' + '(' vfrStatementExpressionSub',' + vfrStatementExpressionSub ',' + guidDefinition ')' + ; + +vfrExpressionParen[ExpInfo] + : '(' vfrStatementExpressionSub ')' + ; + +vfrExpressionBuildInFunction[ExpInfo] + : dupExp[ExpInfo] + | vareqvalExp[ExpInfo] + | ideqvalExp[ExpInfo] + | ideqidExp[ExpInfo] + | ideqvallistExp[ExpInfo] + | questionref1Exp[ExpInfo] + | rulerefExp[ExpInfo] + | stringref1Exp[ExpInfo] + | pushthisExp[ExpInfo] + | securityExp[ExpInfo] + | getExp[ExpInfo] + ; + +dupExp[ExpInfo] +locals[DObj=None] + : 'dup' + ; + + +vareqvalExp[ExpInfo] + : 'vareqval' + 'var' '(' Number ')' + ( '==' Number + | '<=' Number + | '<' Number + | '>=' Number + | '>' Number + ) + ; + +ideqvalExp[ExpInfo] + : I='ideqval' vfrQuestionDataFieldName + ( '==' Number + | '<=' Number + | '<' Number + | '>=' Number + | '>' Number + ) + ; + +ideqidExp[ExpInfo] + : I='ideqid' vfrQuestionDataFieldName + ( E='==' vfrQuestionDataFieldName + | LE='<=' vfrQuestionDataFieldName + | L='<' vfrQuestionDataFieldName + | BE='>=' vfrQuestionDataFieldName + | B='>' vfrQuestionDataFieldName + ) + ; + +ideqvallistExp[ExpInfo] + : 'ideqvallist' vfrQuestionDataFieldName '==' (Number)+ + ; + +vfrQuestionDataFieldName +locals[QId=EFI_QUESTION_ID_INVALID, Mask=0, VarIdStr='', Line=None] + : (SN1=StringIdentifier '[' I=Number ']') # vfrQuestionDataFieldNameRule1 + | (SN2=StringIdentifier ('.' arrayName)*) # vfrQuestionDataFieldNameRule2 + ; + +arrayName +locals[SubStr='', SubStrZ=''] + : StringIdentifier ('[' N=Number ']')? + ; + +questionref1Exp[ExpInfo] + : 'questionref' + '(' ( StringIdentifier | Number ) ')' + ; + +rulerefExp[ExpInfo] + : 'ruleref' '(' StringIdentifier ')' + ; + +stringref1Exp[ExpInfo] + : 'stringref' '(' + ( + 'STRING_TOKEN' '(' Number ')' + | Number + ) + + + ')' + ; + +pushthisExp[ExpInfo] + : 'pushthis' + ; + +securityExp[ExpInfo] + : 'security' '(' guidDefinition ')' + ; + +numericVarStoreType +locals[VarType] + : 'NUMERIC_SIZE_1' + | 'NUMERIC_SIZE_2' + | 'NUMERIC_SIZE_4' + | 'NUMERIC_SIZE_8' + ; + +getExp[ExpInfo] +locals[BaseInfo=EFI_VARSTORE_INFO(), GObj=None] + : 'get' '(' vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '=' numericVarStoreType)? ')' + ; + +vfrExpressionConstant[ExpInfo] + : 'TRUE' + | 'FALSE' + | 'ONE' + | 'ONES' + | 'ZERO' + | 'UNDEFINED' + | 'VERSION' + | Number + ; + +vfrExpressionUnaryOp[ExpInfo] + : lengthExp[ExpInfo] + | bitwisenotExp[ExpInfo] + | question23refExp[ExpInfo] + | stringref2Exp[ExpInfo] + | toboolExp[ExpInfo] + | tostringExp[ExpInfo] + | unintExp[ExpInfo] + | toupperExp[ExpInfo] + | tolwerExp[ExpInfo] + | setExp[ExpInfo] + ; + +lengthExp[ExpInfo] +locals[LObj=None] + : 'length' '(' vfrStatementExpressionSub ')' + ; + +bitwisenotExp[ExpInfo] +locals[BWNObj=None] + : '~' '(' vfrStatementExpressionSub ')' + ; + +question23refExp[ExpInfo] + : 'questionrefval' + '(' + (DevicePath '=' 'STRING_TOKEN' '(' Number ')' ',' )? + (Uuid '=' guidDefinition ',' )? + vfrStatementExpressionSub + ')' + ; + +stringref2Exp[ExpInfo] +locals[SR2Obj=None] + : 'stringrefval' '(' vfrStatementExpressionSub ')' + ; + +toboolExp[ExpInfo] +locals[TBObj=None] + : 'boolval' '(' vfrStatementExpressionSub ')' + ; + +tostringExp[ExpInfo] +locals[TSObj=None] + : 'stringval' ('format' '=' Number ',' )? + '(' vfrStatementExpressionSub ')' + ; + +unintExp[ExpInfo] +locals[TUObj=None] + : 'unintval' '(' vfrStatementExpressionSub ')' + ; + +toupperExp[ExpInfo] +locals[TUObj=None] + : 'toupper' '(' vfrStatementExpressionSub ')' + ; + +tolwerExp[ExpInfo] +locals[TLObj=None] + : 'tolower' '(' vfrStatementExpressionSub ')' + ; + +setExp[ExpInfo] +locals[BaseInfo=EFI_VARSTORE_INFO(), TSObj=None] + : 'set' + '(' + vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '=' numericVarStoreType)? ',' + vfrStatementExpressionSub + ')' + ; + +vfrExpressionTernaryOp[ExpInfo] + : conditionalExp[ExpInfo] + | findExp[ExpInfo] + | midExp[ExpInfo] + | tokenExp[ExpInfo] + | spanExp[ExpInfo] + ; + +conditionalExp[ExpInfo] +locals[CObj=None] + : 'cond' + '(' + vfrStatementExpressionSub // + '?' + vfrStatementExpressionSub // + ':' + vfrStatementExpressionSub // + ')' + ; + +findExp[ExpInfo] +locals[FObj=None] + : 'find' + '(' + findFormat[ExpInfo] ('|' findFormat[ExpInfo])* + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ')' + ; + +findFormat[ExpInfo] +locals[Format=0] + : 'SENSITIVE' | 'INSENSITIVE' + ; + +midExp[ExpInfo] +locals[MObj=None] + : 'mid' + '(' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ')' + ; + +tokenExp[ExpInfo] +locals[TObj=None] + : 'token' + '(' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ')' + ; + +spanExp[ExpInfo] +locals[SObj=None] + : 'span' + '(' + 'flags' '=' spanFlags ('|' spanFlags)* + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ',' + vfrStatementExpressionSub + ')' + ; + +spanFlags +locals[Flag=0] + : Number + | 'LAST_NON_MATCH' + | 'FIRST_NON_MATCH' + ; + +vfrExpressionMap[ExpInfo] +locals[MObj=None] + : 'map' + '(' + vfrStatementExpressionSub + ':' + ( vfrStatementExpression + ',' + vfrStatementExpression + ';' + )* + ')' + ; + + +Define :'#define'; +Include : '#include'; +FormPkgType : 'formpkgtype'; +OpenBrace : '{'; +CloseBrace : '}'; +OpenParen : '('; +CloseParen : ')'; +OpenBracket : '['; +CloseBracket : ']'; +Dot : '.'; +Negative : '-'; +Colon : ':'; +Slash : '/'; +Semicolon : ';'; +Comma : ','; +Equal : '=='; +NotEqual : '!='; +LessEqual: '<='; +Less:'<'; +GreaterEqual:'>='; +Greater:'>'; +BitWiseOr: '|'; +BitWiseAnd: '&'; + +DevicePath : 'devicepath'; +FormSet : 'formset'; +FormSetId : 'formsetid'; +EndFormSet : 'endformset'; +Title : 'title'; +FormId : 'formid'; +OneOf : 'oneof'; +EndOneOf : 'endoneof'; +Prompt : 'prompt'; +OrderedList : 'orderedlist'; +MaxContainers : 'maxcontainers'; +EndList : 'endlist'; +EndForm : 'endform'; +Form : 'form'; +FormMap : 'formmap'; +MapTitle : 'maptitle'; +MapGuid : 'mapguid'; +Subtitle : 'subtitle'; +EndSubtitle : 'endsubtitle'; +Help : 'help'; +Text : 'text'; +Option : 'option'; +FLAGS : 'flags'; +Date : 'date'; +EndDate : 'enddate'; +Year : 'year'; +Month : 'month'; +Day : 'day'; +Time : 'time'; +EndTime : 'endtime'; +Hour : 'hour'; +Minute : 'minute'; +Second : 'second'; +GrayOutIf : 'grayoutif'; +Label : 'label'; +Timeout : 'timeout'; +Inventory : 'inventory'; +NonNvDataMap : '_NON_NV_DATA_MAP'; +Struct : 'struct'; +Union : 'union'; +Boolean : 'BOOLEAN'; +Uint64 : 'UINT64'; +Uint32 : 'UINT32'; +Uint16 : 'UINT16'; +Uint8 :'UINT8'; +EFI_STRING_ID :'EFI_STRING_ID'; +EFI_HII_DATE : 'EFI_HII_DATE'; +EFI_HII_TIME : 'EFI_HII_TIME'; +EFI_HII_REF : 'EFI_HII_REF'; +Uuid : 'guid'; +CheckBox : 'checkbox'; +EndCheckBox : 'endcheckbox'; +Numeric : 'numeric'; +EndNumeric : 'endnumeric'; +Minimum : 'minimum'; +Maximum : 'maximum'; +Step : 'step'; +Default : 'default'; +Password : 'password'; +EndPassword : 'endpassword'; +String : 'string'; +EndString : 'endstring'; +MinSize : 'minsize'; +MaxSize : 'maxsize'; +Encoding : 'encoding'; +SuppressIf : 'suppressif'; +DisableIf : 'disableif'; +Hidden : 'hidden'; +Goto : 'goto'; +FormSetGuid : 'formsetguid'; +InconsistentIf : 'inconsistentif'; +WarningIf : 'warningif'; +NoSubmitIf : 'nosubmitif'; +EndIf : 'endif'; +Key : 'key'; +DefaultFlag : 'DEFAULT'; +ManufacturingFlag : 'MANUFACTURING'; +CheckBoxDefaultFlag : 'CHECKBOX_DEFAULT'; +CheckBoxDefaultMfgFlag : 'CHECKBOX_DEFAULT_MFG'; +InteractiveFlag : 'INTERACTIVE'; +NVAccessFlag : 'NV_ACCESS'; +ResetRequiredFlag : 'RESET_REQUIRED'; +ReconnectRequiredFlag : 'RECONNECT_REQUIRED'; +LateCheckFlag : 'LATE_CHECK'; +ReadOnlyFlag : 'READ_ONLY'; +OptionOnlyFlag : 'OPTIONS_ONLY'; +RestStyleFlag : 'REST_STYLE'; +Class : 'class'; +Subclass : 'subclass'; +ClassGuid : 'classguid'; +TypeDef : 'typedef'; +Restore : 'restore'; +Save : 'save'; +Defaults : 'defaults'; +Banner : 'banner'; +Align : 'align'; +Left : 'left'; +Right : 'right'; +Center : 'center'; +Line : 'line'; +Name : 'name'; + +VarId: 'varid'; +Question: 'question'; +QuestionId: 'questionid'; +Image: 'image'; +Locked: 'locked'; +Rule: 'rule'; +EndRule: 'endrule'; +Value: 'value'; +Read: 'read'; +Write: 'write'; +ResetButton: 'resetbutton'; +EndResetButton: 'endresetbutton'; +DefaultStore: 'defaultstore'; +Attribute: 'attribute'; +Varstore: 'varstore'; +Efivarstore: 'efivarstore'; +VarSize: 'varsize'; +NameValueVarStore: 'namevaluevarstore'; +Action: 'action'; +Config: 'config'; +EndAction: 'endaction'; +Refresh: 'refresh'; +Interval: 'interval'; +VarstoreDevice: 'varstoredevice'; +GuidOp: 'guidop'; +EndGuidOp: 'endguidop'; +DataType: 'datatype'; +Data: 'data'; +Modal: 'modal'; + +// +// Define the class and subclass tokens +// +// +ClassNonDevice: 'NON_DEVICE'; +ClassDiskDevice: 'DISK_DEVICE'; +ClassVideoDevice: 'VIDEO_DEVICE'; +ClassNetworkDevice: 'NETWORK_DEVICE'; +ClassInputDevice: 'INPUT_DEVICE'; +ClassOnBoardDevice: 'ONBOARD_DEVICE'; +ClassOtherDevice: 'OTHER_DEVICE'; + +SubclassSetupApplication: 'SETUP_APPLICATION'; +SubclassGeneralApplication: 'GENERAL_APPLICATION'; +SubclassFrontPage: 'FRONT_PAGE'; +SubclassSingleUse: 'SINGLE_USE'; + +YearSupppressFlag: 'YEAR_SUPPRESS'; +MonthSuppressFlag: 'MONTH_SUPPRESS'; +DaySuppressFlag: 'DAY_SUPPRESS'; +HourSupppressFlag: 'HOUR_SUPPRESS'; +MinuteSuppressFlag: 'MINUTE_SUPPRESS'; +SecondSuppressFlag: 'SECOND_SUPPRESS'; +StorageNormalFlag: 'STORAGE_NORMAL'; +StorageTimeFlag: 'STORAGE_TIME'; +StorageWakeUpFlag: 'STORAGE_WAKEUP'; + +UniQueFlag: 'UNIQUE'; +NoEmptyFlag: 'NOEMPTY'; + +Cond: 'cond'; +Find: 'find'; +Mid: 'mid'; +Tok: 'token'; +Span: 'span'; + +// The syntax of expression + +Dup: 'dup'; +VarEqVal: 'vareqval'; +Var: 'var'; +IdEqVal: 'ideqval'; +IdEqId: 'ideqid'; +IdEqValList: 'ideqvallist'; +QuestionRef: 'questionref'; +RuleRef: 'ruleref'; +StringRef: 'stringref'; +PushThis: 'pushthis'; +Security: 'security'; +Get: 'get'; +TrueSymbol: 'TRUE'; +FalseSymbol: 'FALSE'; +One: 'ONE'; +Ones: 'ONES'; +Zero: 'ZERO'; +Undefined: 'UNDEFINED'; +Version: 'VERSION'; +Length: 'length'; +AND: 'AND'; +OR: 'OR'; +NOT: 'NOT'; +Set: 'set'; +BitWiseNot: '~'; +BoolVal: 'boolval'; +StringVal: 'stringval'; +UnIntVal: 'unintval'; +ToUpper: 'toupper'; +ToLower: 'tolower'; +Match: 'match'; +Match2: 'match2'; +Catenate: 'catenate'; +QuestionRefVal: 'questionrefval'; +StringRefVal: 'stringrefval'; +Map: 'map'; +RefreshGuid: 'refreshguid'; +StringToken: 'STRING_TOKEN'; + +OptionDefault: 'OPTION_DEFAULT'; +OptionDefaultMfg: 'OPTION_DEFAULT_MFG'; + +NumericSizeOne: 'NUMERIC_SIZE_1'; +NumericSizeTwo: 'NUMERIC_SIZE_2'; +NumericSizeFour: 'NUMERIC_SIZE_4'; +NumericSizeEight: 'NUMERIC_SIZE_8'; +DisPlayIntDec: 'DISPLAY_INT_DEC'; +DisPlayUIntDec: 'DISPLAY_UINT_DEC'; +DisPlayUIntHex: 'DISPLAY_UINT_HEX'; + +Insensitive: 'INSENSITIVE'; +Sensitive: 'SENSITIVE'; + +LastNonMatch: 'LAST_NON_MATCH'; +FirstNonMatch: 'FIRST_NON_MATCH'; + + + +Number + : ('0x'[0-9A-Fa-f]+) | [0-9]+ + ; + +StringIdentifier + : [A-Za-z_][A-Za-z_0-9]* + ; + +ComplexDefine + : '#' Whitespace? 'define' ~[#\r\n]* + -> skip + ; + + +LineDefinition + : '#' Whitespace? 'line' ~[#\r\n]* + -> skip + ; + +IncludeDefinition + : '#' Whitespace? 'include' ~[#\r\n]* + -> skip + ; + +Whitespace + : [ \t]+ + -> skip + ; + +Newline + : ( '\r' '\n'? + | '\n' + ) + -> skip + ; + +LineComment + : '//' ~[\r\n]* + -> skip + ; + +// Skip over 'extern' in any included .H file +Extern + : 'extern' ~[#\r\n]* + -> skip + ; \ No newline at end of file diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py new file mode 100644 index 0000000000..2b7a5c32a3 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py @@ -0,0 +1,1709 @@ +# Generated from VfrSyntax.g4 by ANTLR 4.7.2 +from antlr4 import * +from io import StringIO +from typing import TextIO +import sys + + + +from VfrCompiler.CommonCtypes import * +from VfrCompiler.VfrFormPkg import * +from VfrCompiler.VfrUtility import * +from VfrCompiler.VfrTree import * + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0102") + buf.write("\u0ab7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7") + buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r") + buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23") + buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30") + buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36") + buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%") + buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.") + buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64") + buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:") + buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t") + buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t") + buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t") + buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4") + buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4") + buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4") + buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4") + buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080") + buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083") + buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087") + buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a") + buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e") + buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091") + buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095") + buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098") + buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c") + buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f") + buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3") + buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6") + buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa") + buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad") + buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1") + buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4") + buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8") + buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb") + buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf") + buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2") + buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6") + buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9") + buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd") + buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0") + buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4") + buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7") + buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db") + buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de") + buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2") + buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5") + buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9") + buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec") + buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0") + buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3") + buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7") + buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa") + buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe") + buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101") + buf.write("\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3") + buf.write("\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6") + buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3") + buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n") + buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3") + buf.write("\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20") + buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\22") + buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23") + buf.write("\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24") + buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31") + buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36") + buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3") + buf.write("%\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3") + buf.write(")\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3") + buf.write("+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3") + buf.write("-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60") + buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61") + buf.write("\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62") + buf.write("\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63") + buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64") + buf.write("\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65") + buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67") + buf.write("\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\39\39\39\3") + buf.write("9\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3") + buf.write(";\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3") + buf.write(">\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3") + buf.write("A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3") + buf.write("C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3") + buf.write("G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3") + buf.write("I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3") + buf.write("L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3") + buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3") + buf.write("O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3") + buf.write("T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3") + buf.write("V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3") + buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3") + buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3") + buf.write("[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\") + buf.write("\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3") + buf.write("^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3") + buf.write("`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3") + buf.write("c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3") + buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3") + buf.write("g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3") + buf.write("i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3k\3k\3") + buf.write("k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3") + buf.write("m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3") + buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3") + buf.write("p\3p\3p\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3") + buf.write("r\3r\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3") + buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3") + buf.write("w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3") + buf.write("x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3z\3z\3") + buf.write("z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3") + buf.write("{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3") + buf.write("|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3") + buf.write("~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3") + buf.write("\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080") + buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081") + buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081") + buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082") + buf.write("\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084") + buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085") + buf.write("\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087") + buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089") + buf.write("\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a") + buf.write("\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d") + buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f") + buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090") + buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090") + buf.write("\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091") + buf.write("\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092") + buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094") + buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094") + buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096") + buf.write("\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097") + buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098") + buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098") + buf.write("\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099") + buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099") + buf.write("\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c") + buf.write("\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d") + buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d") + buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e") + buf.write("\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f") + buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f") + buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f") + buf.write("\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0") + buf.write("\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1") + buf.write("\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2") + buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3") + buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4") + buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4") + buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5") + buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5") + buf.write("\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6") + buf.write("\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7") + buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8") + buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa") + buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab") + buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab") + buf.write("\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac") + buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad") + buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad") + buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af") + buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af") + buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0") + buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0") + buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1") + buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1") + buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4") + buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5") + buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5") + buf.write("\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6") + buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6") + buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9") + buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9") + buf.write("\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba") + buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba") + buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb") + buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb") + buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc") + buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd") + buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be") + buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be") + buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be") + buf.write("\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf") + buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0") + buf.write("\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2") + buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3") + buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4") + buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6") + buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7") + buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8") + buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9") + buf.write("\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca") + buf.write("\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc") + buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd") + buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce") + buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce") + buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf") + buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0") + buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1") + buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2") + buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3") + buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5") + buf.write("\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6") + buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7") + buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8") + buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9") + buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da") + buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc") + buf.write("\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de") + buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df") + buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0") + buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1") + buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2") + buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2") + buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3") + buf.write("\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4") + buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5") + buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6") + buf.write("\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7") + buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7") + buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea") + buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea") + buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb") + buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb") + buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec") + buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec") + buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed") + buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed") + buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed") + buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee") + buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee") + buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef") + buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef") + buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0") + buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0") + buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1") + buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1") + buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2") + buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2") + buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2") + buf.write("\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3") + buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3") + buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4") + buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4") + buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4") + buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5") + buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6") + buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6") + buf.write("\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7") + buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7") + buf.write("\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8") + buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8") + buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9") + buf.write("\3\u00f9\6\u00f9\u0a44\n\u00f9\r\u00f9\16\u00f9\u0a45") + buf.write("\3\u00f9\6\u00f9\u0a49\n\u00f9\r\u00f9\16\u00f9\u0a4a") + buf.write("\5\u00f9\u0a4d\n\u00f9\3\u00fa\3\u00fa\7\u00fa\u0a51\n") + buf.write("\u00fa\f\u00fa\16\u00fa\u0a54\13\u00fa\3\u00fb\3\u00fb") + buf.write("\5\u00fb\u0a58\n\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fb") + buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fb\7\u00fb\u0a62\n\u00fb") + buf.write("\f\u00fb\16\u00fb\u0a65\13\u00fb\3\u00fb\3\u00fb\3\u00fc") + buf.write("\3\u00fc\5\u00fc\u0a6b\n\u00fc\3\u00fc\3\u00fc\3\u00fc") + buf.write("\3\u00fc\3\u00fc\3\u00fc\7\u00fc\u0a73\n\u00fc\f\u00fc") + buf.write("\16\u00fc\u0a76\13\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd") + buf.write("\5\u00fd\u0a7c\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd") + buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\7\u00fd\u0a87") + buf.write("\n\u00fd\f\u00fd\16\u00fd\u0a8a\13\u00fd\3\u00fd\3\u00fd") + buf.write("\3\u00fe\6\u00fe\u0a8f\n\u00fe\r\u00fe\16\u00fe\u0a90") + buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\5\u00ff\u0a97\n\u00ff") + buf.write("\3\u00ff\5\u00ff\u0a9a\n\u00ff\3\u00ff\3\u00ff\3\u0100") + buf.write("\3\u0100\3\u0100\3\u0100\7\u0100\u0aa2\n\u0100\f\u0100") + buf.write("\16\u0100\u0aa5\13\u0100\3\u0100\3\u0100\3\u0101\3\u0101") + buf.write("\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\7\u0101") + buf.write("\u0ab1\n\u0101\f\u0101\16\u0101\u0ab4\13\u0101\3\u0101") + buf.write("\3\u0101\2\2\u0102\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n") + buf.write("\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'") + buf.write("\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ") + buf.write("?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g") + buf.write("\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085") + buf.write("D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095") + buf.write("L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5") + buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5") + buf.write("\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5") + buf.write("d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5") + buf.write("l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5") + buf.write("t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1z\u00f3{\u00f5") + buf.write("|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff\u0081\u0101") + buf.write("\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086") + buf.write("\u010b\u0087\u010d\u0088\u010f\u0089\u0111\u008a\u0113") + buf.write("\u008b\u0115\u008c\u0117\u008d\u0119\u008e\u011b\u008f") + buf.write("\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125") + buf.write("\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098") + buf.write("\u012f\u0099\u0131\u009a\u0133\u009b\u0135\u009c\u0137") + buf.write("\u009d\u0139\u009e\u013b\u009f\u013d\u00a0\u013f\u00a1") + buf.write("\u0141\u00a2\u0143\u00a3\u0145\u00a4\u0147\u00a5\u0149") + buf.write("\u00a6\u014b\u00a7\u014d\u00a8\u014f\u00a9\u0151\u00aa") + buf.write("\u0153\u00ab\u0155\u00ac\u0157\u00ad\u0159\u00ae\u015b") + buf.write("\u00af\u015d\u00b0\u015f\u00b1\u0161\u00b2\u0163\u00b3") + buf.write("\u0165\u00b4\u0167\u00b5\u0169\u00b6\u016b\u00b7\u016d") + buf.write("\u00b8\u016f\u00b9\u0171\u00ba\u0173\u00bb\u0175\u00bc") + buf.write("\u0177\u00bd\u0179\u00be\u017b\u00bf\u017d\u00c0\u017f") + buf.write("\u00c1\u0181\u00c2\u0183\u00c3\u0185\u00c4\u0187\u00c5") + buf.write("\u0189\u00c6\u018b\u00c7\u018d\u00c8\u018f\u00c9\u0191") + buf.write("\u00ca\u0193\u00cb\u0195\u00cc\u0197\u00cd\u0199\u00ce") + buf.write("\u019b\u00cf\u019d\u00d0\u019f\u00d1\u01a1\u00d2\u01a3") + buf.write("\u00d3\u01a5\u00d4\u01a7\u00d5\u01a9\u00d6\u01ab\u00d7") + buf.write("\u01ad\u00d8\u01af\u00d9\u01b1\u00da\u01b3\u00db\u01b5") + buf.write("\u00dc\u01b7\u00dd\u01b9\u00de\u01bb\u00df\u01bd\u00e0") + buf.write("\u01bf\u00e1\u01c1\u00e2\u01c3\u00e3\u01c5\u00e4\u01c7") + buf.write("\u00e5\u01c9\u00e6\u01cb\u00e7\u01cd\u00e8\u01cf\u00e9") + buf.write("\u01d1\u00ea\u01d3\u00eb\u01d5\u00ec\u01d7\u00ed\u01d9") + buf.write("\u00ee\u01db\u00ef\u01dd\u00f0\u01df\u00f1\u01e1\u00f2") + buf.write("\u01e3\u00f3\u01e5\u00f4\u01e7\u00f5\u01e9\u00f6\u01eb") + buf.write("\u00f7\u01ed\u00f8\u01ef\u00f9\u01f1\u00fa\u01f3\u00fb") + buf.write("\u01f5\u00fc\u01f7\u00fd\u01f9\u00fe\u01fb\u00ff\u01fd") + buf.write("\u0100\u01ff\u0101\u0201\u0102\3\2\t\5\2\62;CHch\3\2\62") + buf.write(";\5\2C\\aac|\6\2\62;C\\aac|\5\2\f\f\17\17%%\4\2\13\13") + buf.write("\"\"\4\2\f\f\17\17\2\u0ac5\2\3\3\2\2\2\2\5\3\2\2\2\2\7") + buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2") + buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2") + buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2") + buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2") + buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63") + buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2") + buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2") + buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3") + buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y") + buf.write("\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2") + buf.write("c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2") + buf.write("\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2") + buf.write("\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3") + buf.write("\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2") + buf.write("\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d") + buf.write("\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2") + buf.write("\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b") + buf.write("\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2") + buf.write("\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9") + buf.write("\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2") + buf.write("\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7") + buf.write("\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2") + buf.write("\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5") + buf.write("\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2") + buf.write("\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3") + buf.write("\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2") + buf.write("\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1") + buf.write("\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2") + buf.write("\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef") + buf.write("\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2") + buf.write("\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd") + buf.write("\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2") + buf.write("\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b") + buf.write("\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2") + buf.write("\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119") + buf.write("\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2") + buf.write("\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127") + buf.write("\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2") + buf.write("\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135") + buf.write("\3\2\2\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2") + buf.write("\2\2\u013d\3\2\2\2\2\u013f\3\2\2\2\2\u0141\3\2\2\2\2\u0143") + buf.write("\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2") + buf.write("\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151") + buf.write("\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2") + buf.write("\2\2\u0159\3\2\2\2\2\u015b\3\2\2\2\2\u015d\3\2\2\2\2\u015f") + buf.write("\3\2\2\2\2\u0161\3\2\2\2\2\u0163\3\2\2\2\2\u0165\3\2\2") + buf.write("\2\2\u0167\3\2\2\2\2\u0169\3\2\2\2\2\u016b\3\2\2\2\2\u016d") + buf.write("\3\2\2\2\2\u016f\3\2\2\2\2\u0171\3\2\2\2\2\u0173\3\2\2") + buf.write("\2\2\u0175\3\2\2\2\2\u0177\3\2\2\2\2\u0179\3\2\2\2\2\u017b") + buf.write("\3\2\2\2\2\u017d\3\2\2\2\2\u017f\3\2\2\2\2\u0181\3\2\2") + buf.write("\2\2\u0183\3\2\2\2\2\u0185\3\2\2\2\2\u0187\3\2\2\2\2\u0189") + buf.write("\3\2\2\2\2\u018b\3\2\2\2\2\u018d\3\2\2\2\2\u018f\3\2\2") + buf.write("\2\2\u0191\3\2\2\2\2\u0193\3\2\2\2\2\u0195\3\2\2\2\2\u0197") + buf.write("\3\2\2\2\2\u0199\3\2\2\2\2\u019b\3\2\2\2\2\u019d\3\2\2") + buf.write("\2\2\u019f\3\2\2\2\2\u01a1\3\2\2\2\2\u01a3\3\2\2\2\2\u01a5") + buf.write("\3\2\2\2\2\u01a7\3\2\2\2\2\u01a9\3\2\2\2\2\u01ab\3\2\2") + buf.write("\2\2\u01ad\3\2\2\2\2\u01af\3\2\2\2\2\u01b1\3\2\2\2\2\u01b3") + buf.write("\3\2\2\2\2\u01b5\3\2\2\2\2\u01b7\3\2\2\2\2\u01b9\3\2\2") + buf.write("\2\2\u01bb\3\2\2\2\2\u01bd\3\2\2\2\2\u01bf\3\2\2\2\2\u01c1") + buf.write("\3\2\2\2\2\u01c3\3\2\2\2\2\u01c5\3\2\2\2\2\u01c7\3\2\2") + buf.write("\2\2\u01c9\3\2\2\2\2\u01cb\3\2\2\2\2\u01cd\3\2\2\2\2\u01cf") + buf.write("\3\2\2\2\2\u01d1\3\2\2\2\2\u01d3\3\2\2\2\2\u01d5\3\2\2") + buf.write("\2\2\u01d7\3\2\2\2\2\u01d9\3\2\2\2\2\u01db\3\2\2\2\2\u01dd") + buf.write("\3\2\2\2\2\u01df\3\2\2\2\2\u01e1\3\2\2\2\2\u01e3\3\2\2") + buf.write("\2\2\u01e5\3\2\2\2\2\u01e7\3\2\2\2\2\u01e9\3\2\2\2\2\u01eb") + buf.write("\3\2\2\2\2\u01ed\3\2\2\2\2\u01ef\3\2\2\2\2\u01f1\3\2\2") + buf.write("\2\2\u01f3\3\2\2\2\2\u01f5\3\2\2\2\2\u01f7\3\2\2\2\2\u01f9") + buf.write("\3\2\2\2\2\u01fb\3\2\2\2\2\u01fd\3\2\2\2\2\u01ff\3\2\2") + buf.write("\2\2\u0201\3\2\2\2\3\u0203\3\2\2\2\5\u0208\3\2\2\2\7\u020d") + buf.write("\3\2\2\2\t\u0211\3\2\2\2\13\u0219\3\2\2\2\r\u021e\3\2") + buf.write("\2\2\17\u0220\3\2\2\2\21\u022c\3\2\2\2\23\u0237\3\2\2") + buf.write("\2\25\u0242\3\2\2\2\27\u0245\3\2\2\2\31\u0248\3\2\2\2") + buf.write("\33\u024a\3\2\2\2\35\u024c\3\2\2\2\37\u024e\3\2\2\2!\u0255") + buf.write("\3\2\2\2#\u0257\3\2\2\2%\u025f\3\2\2\2\'\u0268\3\2\2\2") + buf.write(")\u0274\3\2\2\2+\u0276\3\2\2\2-\u0278\3\2\2\2/\u027a\3") + buf.write("\2\2\2\61\u027c\3\2\2\2\63\u027e\3\2\2\2\65\u0280\3\2") + buf.write("\2\2\67\u0282\3\2\2\29\u0284\3\2\2\2;\u0286\3\2\2\2=\u0288") + buf.write("\3\2\2\2?\u028a\3\2\2\2A\u028c\3\2\2\2C\u028f\3\2\2\2") + buf.write("E\u0292\3\2\2\2G\u0295\3\2\2\2I\u0297\3\2\2\2K\u029a\3") + buf.write("\2\2\2M\u029c\3\2\2\2O\u029e\3\2\2\2Q\u02a0\3\2\2\2S\u02ab") + buf.write("\3\2\2\2U\u02b3\3\2\2\2W\u02bd\3\2\2\2Y\u02c8\3\2\2\2") + buf.write("[\u02ce\3\2\2\2]\u02d5\3\2\2\2_\u02db\3\2\2\2a\u02e4\3") + buf.write("\2\2\2c\u02eb\3\2\2\2e\u02f7\3\2\2\2g\u0305\3\2\2\2i\u030d") + buf.write("\3\2\2\2k\u0315\3\2\2\2m\u031a\3\2\2\2o\u0322\3\2\2\2") + buf.write("q\u032b\3\2\2\2s\u0333\3\2\2\2u\u033c\3\2\2\2w\u0348\3") + buf.write("\2\2\2y\u034d\3\2\2\2{\u0352\3\2\2\2}\u0359\3\2\2\2\177") + buf.write("\u035f\3\2\2\2\u0081\u0364\3\2\2\2\u0083\u036c\3\2\2\2") + buf.write("\u0085\u0371\3\2\2\2\u0087\u0377\3\2\2\2\u0089\u037b\3") + buf.write("\2\2\2\u008b\u0380\3\2\2\2\u008d\u0388\3\2\2\2\u008f\u038d") + buf.write("\3\2\2\2\u0091\u0394\3\2\2\2\u0093\u039b\3\2\2\2\u0095") + buf.write("\u03a5\3\2\2\2\u0097\u03ab\3\2\2\2\u0099\u03b3\3\2\2\2") + buf.write("\u009b\u03bd\3\2\2\2\u009d\u03ce\3\2\2\2\u009f\u03d5\3") + buf.write("\2\2\2\u00a1\u03db\3\2\2\2\u00a3\u03e3\3\2\2\2\u00a5\u03ea") + buf.write("\3\2\2\2\u00a7\u03f1\3\2\2\2\u00a9\u03f8\3\2\2\2\u00ab") + buf.write("\u03fe\3\2\2\2\u00ad\u040c\3\2\2\2\u00af\u0419\3\2\2\2") + buf.write("\u00b1\u0426\3\2\2\2\u00b3\u0432\3\2\2\2\u00b5\u0437\3") + buf.write("\2\2\2\u00b7\u0440\3\2\2\2\u00b9\u044c\3\2\2\2\u00bb\u0454") + buf.write("\3\2\2\2\u00bd\u045f\3\2\2\2\u00bf\u0467\3\2\2\2\u00c1") + buf.write("\u046f\3\2\2\2\u00c3\u0474\3\2\2\2\u00c5\u047c\3\2\2\2") + buf.write("\u00c7\u0485\3\2\2\2\u00c9\u0491\3\2\2\2\u00cb\u0498\3") + buf.write("\2\2\2\u00cd\u04a2\3\2\2\2\u00cf\u04aa\3\2\2\2\u00d1\u04b2") + buf.write("\3\2\2\2\u00d3\u04bb\3\2\2\2\u00d5\u04c6\3\2\2\2\u00d7") + buf.write("\u04d0\3\2\2\2\u00d9\u04d7\3\2\2\2\u00db\u04dc\3\2\2\2") + buf.write("\u00dd\u04e8\3\2\2\2\u00df\u04f7\3\2\2\2\u00e1\u0501\3") + buf.write("\2\2\2\u00e3\u050c\3\2\2\2\u00e5\u0512\3\2\2\2\u00e7\u0516") + buf.write("\3\2\2\2\u00e9\u051e\3\2\2\2\u00eb\u052c\3\2\2\2\u00ed") + buf.write("\u053d\3\2\2\2\u00ef\u0552\3\2\2\2\u00f1\u055e\3\2\2\2") + buf.write("\u00f3\u0568\3\2\2\2\u00f5\u0577\3\2\2\2\u00f7\u058a\3") + buf.write("\2\2\2\u00f9\u0595\3\2\2\2\u00fb\u059f\3\2\2\2\u00fd\u05ac") + buf.write("\3\2\2\2\u00ff\u05b7\3\2\2\2\u0101\u05bd\3\2\2\2\u0103") + buf.write("\u05c6\3\2\2\2\u0105\u05d0\3\2\2\2\u0107\u05d8\3\2\2\2") + buf.write("\u0109\u05e0\3\2\2\2\u010b\u05e5\3\2\2\2\u010d\u05ee\3") + buf.write("\2\2\2\u010f\u05f5\3\2\2\2\u0111\u05fb\3\2\2\2\u0113\u0600") + buf.write("\3\2\2\2\u0115\u0606\3\2\2\2\u0117\u060d\3\2\2\2\u0119") + buf.write("\u0612\3\2\2\2\u011b\u0617\3\2\2\2\u011d\u061d\3\2\2\2") + buf.write("\u011f\u0626\3\2\2\2\u0121\u0631\3\2\2\2\u0123\u0637\3") + buf.write("\2\2\2\u0125\u063e\3\2\2\2\u0127\u0643\3\2\2\2\u0129\u064b") + buf.write("\3\2\2\2\u012b\u0651\3\2\2\2\u012d\u0656\3\2\2\2\u012f") + buf.write("\u065c\3\2\2\2\u0131\u0668\3\2\2\2\u0133\u0677\3\2\2\2") + buf.write("\u0135\u0684\3\2\2\2\u0137\u068e\3\2\2\2\u0139\u0697\3") + buf.write("\2\2\2\u013b\u06a3\3\2\2\2\u013d\u06ab\3\2\2\2\u013f\u06bd") + buf.write("\3\2\2\2\u0141\u06c4\3\2\2\2\u0143\u06cb\3\2\2\2\u0145") + buf.write("\u06d5\3\2\2\2\u0147\u06dd\3\2\2\2\u0149\u06e6\3\2\2\2") + buf.write("\u014b\u06f5\3\2\2\2\u014d\u06fc\3\2\2\2\u014f\u0706\3") + buf.write("\2\2\2\u0151\u070f\3\2\2\2\u0153\u0714\3\2\2\2\u0155\u071a") + buf.write("\3\2\2\2\u0157\u0725\3\2\2\2\u0159\u0731\3\2\2\2\u015b") + buf.write("\u073e\3\2\2\2\u015d\u074d\3\2\2\2\u015f\u075a\3\2\2\2") + buf.write("\u0161\u0769\3\2\2\2\u0163\u0776\3\2\2\2\u0165\u0788\3") + buf.write("\2\2\2\u0167\u079c\3\2\2\2\u0169\u07a7\3\2\2\2\u016b\u07b2") + buf.write("\3\2\2\2\u016d\u07c0\3\2\2\2\u016f\u07cf\3\2\2\2\u0171") + buf.write("\u07dc\3\2\2\2\u0173\u07ea\3\2\2\2\u0175\u07fa\3\2\2\2") + buf.write("\u0177\u080a\3\2\2\2\u0179\u0819\3\2\2\2\u017b\u0826\3") + buf.write("\2\2\2\u017d\u0835\3\2\2\2\u017f\u083c\3\2\2\2\u0181\u0844") + buf.write("\3\2\2\2\u0183\u0849\3\2\2\2\u0185\u084e\3\2\2\2\u0187") + buf.write("\u0852\3\2\2\2\u0189\u0858\3\2\2\2\u018b\u085d\3\2\2\2") + buf.write("\u018d\u0861\3\2\2\2\u018f\u086a\3\2\2\2\u0191\u086e\3") + buf.write("\2\2\2\u0193\u0876\3\2\2\2\u0195\u087d\3\2\2\2\u0197\u0889") + buf.write("\3\2\2\2\u0199\u0895\3\2\2\2\u019b\u089d\3\2\2\2\u019d") + buf.write("\u08a7\3\2\2\2\u019f\u08b0\3\2\2\2\u01a1\u08b9\3\2\2\2") + buf.write("\u01a3\u08bd\3\2\2\2\u01a5\u08c2\3\2\2\2\u01a7\u08c8\3") + buf.write("\2\2\2\u01a9\u08cc\3\2\2\2\u01ab\u08d1\3\2\2\2\u01ad\u08d6") + buf.write("\3\2\2\2\u01af\u08e0\3\2\2\2\u01b1\u08e8\3\2\2\2\u01b3") + buf.write("\u08ef\3\2\2\2\u01b5\u08f3\3\2\2\2\u01b7\u08f6\3\2\2\2") + buf.write("\u01b9\u08fa\3\2\2\2\u01bb\u08fe\3\2\2\2\u01bd\u0900\3") + buf.write("\2\2\2\u01bf\u0908\3\2\2\2\u01c1\u0912\3\2\2\2\u01c3\u091b") + buf.write("\3\2\2\2\u01c5\u0923\3\2\2\2\u01c7\u092b\3\2\2\2\u01c9") + buf.write("\u0931\3\2\2\2\u01cb\u0938\3\2\2\2\u01cd\u0941\3\2\2\2") + buf.write("\u01cf\u0950\3\2\2\2\u01d1\u095d\3\2\2\2\u01d3\u0961\3") + buf.write("\2\2\2\u01d5\u096d\3\2\2\2\u01d7\u097a\3\2\2\2\u01d9\u0989") + buf.write("\3\2\2\2\u01db\u099c\3\2\2\2\u01dd\u09ab\3\2\2\2\u01df") + buf.write("\u09ba\3\2\2\2\u01e1\u09c9\3\2\2\2\u01e3\u09d8\3\2\2\2") + buf.write("\u01e5\u09e8\3\2\2\2\u01e7\u09f9\3\2\2\2\u01e9\u0a0a\3") + buf.write("\2\2\2\u01eb\u0a16\3\2\2\2\u01ed\u0a20\3\2\2\2\u01ef\u0a2f") + buf.write("\3\2\2\2\u01f1\u0a4c\3\2\2\2\u01f3\u0a4e\3\2\2\2\u01f5") + buf.write("\u0a55\3\2\2\2\u01f7\u0a68\3\2\2\2\u01f9\u0a79\3\2\2\2") + buf.write("\u01fb\u0a8e\3\2\2\2\u01fd\u0a99\3\2\2\2\u01ff\u0a9d\3") + buf.write("\2\2\2\u0201\u0aa8\3\2\2\2\u0203\u0204\7u\2\2\u0204\u0205") + buf.write("\7j\2\2\u0205\u0206\7q\2\2\u0206\u0207\7y\2\2\u0207\4") + buf.write("\3\2\2\2\u0208\u0209\7r\2\2\u0209\u020a\7w\2\2\u020a\u020b") + buf.write("\7u\2\2\u020b\u020c\7j\2\2\u020c\6\3\2\2\2\u020d\u020e") + buf.write("\7r\2\2\u020e\u020f\7q\2\2\u020f\u0210\7r\2\2\u0210\b") + buf.write("\3\2\2\2\u0211\u0212\7%\2\2\u0212\u0213\7r\2\2\u0213\u0214") + buf.write("\7t\2\2\u0214\u0215\7c\2\2\u0215\u0216\7i\2\2\u0216\u0217") + buf.write("\7o\2\2\u0217\u0218\7c\2\2\u0218\n\3\2\2\2\u0219\u021a") + buf.write("\7r\2\2\u021a\u021b\7c\2\2\u021b\u021c\7e\2\2\u021c\u021d") + buf.write("\7m\2\2\u021d\f\3\2\2\2\u021e\u021f\7?\2\2\u021f\16\3") + buf.write("\2\2\2\u0220\u0221\7K\2\2\u0221\u0222\7O\2\2\u0222\u0223") + buf.write("\7C\2\2\u0223\u0224\7I\2\2\u0224\u0225\7G\2\2\u0225\u0226") + buf.write("\7a\2\2\u0226\u0227\7V\2\2\u0227\u0228\7Q\2\2\u0228\u0229") + buf.write("\7M\2\2\u0229\u022a\7G\2\2\u022a\u022b\7P\2\2\u022b\20") + buf.write("\3\2\2\2\u022c\u022d\7J\2\2\u022d\u022e\7Q\2\2\u022e\u022f") + buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u0232") + buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u0235") + buf.write("\7C\2\2\u0235\u0236\7N\2\2\u0236\22\3\2\2\2\u0237\u0238") + buf.write("\7O\2\2\u0238\u0239\7W\2\2\u0239\u023a\7N\2\2\u023a\u023b") + buf.write("\7V\2\2\u023b\u023c\7K\2\2\u023c\u023d\7a\2\2\u023d\u023e") + buf.write("\7N\2\2\u023e\u023f\7K\2\2\u023f\u0240\7P\2\2\u0240\u0241") + buf.write("\7G\2\2\u0241\24\3\2\2\2\u0242\u0243\7>\2\2\u0243\u0244") + buf.write("\7>\2\2\u0244\26\3\2\2\2\u0245\u0246\7@\2\2\u0246\u0247") + buf.write("\7@\2\2\u0247\30\3\2\2\2\u0248\u0249\7-\2\2\u0249\32\3") + buf.write("\2\2\2\u024a\u024b\7,\2\2\u024b\34\3\2\2\2\u024c\u024d") + buf.write("\7\'\2\2\u024d\36\3\2\2\2\u024e\u024f\7h\2\2\u024f\u0250") + buf.write("\7q\2\2\u0250\u0251\7t\2\2\u0251\u0252\7o\2\2\u0252\u0253") + buf.write("\7c\2\2\u0253\u0254\7v\2\2\u0254 \3\2\2\2\u0255\u0256") + buf.write("\7A\2\2\u0256\"\3\2\2\2\u0257\u0258\7%\2\2\u0258\u0259") + buf.write("\7f\2\2\u0259\u025a\7g\2\2\u025a\u025b\7h\2\2\u025b\u025c") + buf.write("\7k\2\2\u025c\u025d\7p\2\2\u025d\u025e\7g\2\2\u025e$\3") + buf.write("\2\2\2\u025f\u0260\7%\2\2\u0260\u0261\7k\2\2\u0261\u0262") + buf.write("\7p\2\2\u0262\u0263\7e\2\2\u0263\u0264\7n\2\2\u0264\u0265") + buf.write("\7w\2\2\u0265\u0266\7f\2\2\u0266\u0267\7g\2\2\u0267&\3") + buf.write("\2\2\2\u0268\u0269\7h\2\2\u0269\u026a\7q\2\2\u026a\u026b") + buf.write("\7t\2\2\u026b\u026c\7o\2\2\u026c\u026d\7r\2\2\u026d\u026e") + buf.write("\7m\2\2\u026e\u026f\7i\2\2\u026f\u0270\7v\2\2\u0270\u0271") + buf.write("\7{\2\2\u0271\u0272\7r\2\2\u0272\u0273\7g\2\2\u0273(\3") + buf.write("\2\2\2\u0274\u0275\7}\2\2\u0275*\3\2\2\2\u0276\u0277\7") + buf.write("\177\2\2\u0277,\3\2\2\2\u0278\u0279\7*\2\2\u0279.\3\2") + buf.write("\2\2\u027a\u027b\7+\2\2\u027b\60\3\2\2\2\u027c\u027d\7") + buf.write("]\2\2\u027d\62\3\2\2\2\u027e\u027f\7_\2\2\u027f\64\3\2") + buf.write("\2\2\u0280\u0281\7\60\2\2\u0281\66\3\2\2\2\u0282\u0283") + buf.write("\7/\2\2\u02838\3\2\2\2\u0284\u0285\7<\2\2\u0285:\3\2\2") + buf.write("\2\u0286\u0287\7\61\2\2\u0287<\3\2\2\2\u0288\u0289\7=") + buf.write("\2\2\u0289>\3\2\2\2\u028a\u028b\7.\2\2\u028b@\3\2\2\2") + buf.write("\u028c\u028d\7?\2\2\u028d\u028e\7?\2\2\u028eB\3\2\2\2") + buf.write("\u028f\u0290\7#\2\2\u0290\u0291\7?\2\2\u0291D\3\2\2\2") + buf.write("\u0292\u0293\7>\2\2\u0293\u0294\7?\2\2\u0294F\3\2\2\2") + buf.write("\u0295\u0296\7>\2\2\u0296H\3\2\2\2\u0297\u0298\7@\2\2") + buf.write("\u0298\u0299\7?\2\2\u0299J\3\2\2\2\u029a\u029b\7@\2\2") + buf.write("\u029bL\3\2\2\2\u029c\u029d\7~\2\2\u029dN\3\2\2\2\u029e") + buf.write("\u029f\7(\2\2\u029fP\3\2\2\2\u02a0\u02a1\7f\2\2\u02a1") + buf.write("\u02a2\7g\2\2\u02a2\u02a3\7x\2\2\u02a3\u02a4\7k\2\2\u02a4") + buf.write("\u02a5\7e\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7r\2\2\u02a7") + buf.write("\u02a8\7c\2\2\u02a8\u02a9\7v\2\2\u02a9\u02aa\7j\2\2\u02aa") + buf.write("R\3\2\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7q\2\2\u02ad") + buf.write("\u02ae\7t\2\2\u02ae\u02af\7o\2\2\u02af\u02b0\7u\2\2\u02b0") + buf.write("\u02b1\7g\2\2\u02b1\u02b2\7v\2\2\u02b2T\3\2\2\2\u02b3") + buf.write("\u02b4\7h\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7t\2\2\u02b6") + buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b9") + buf.write("\u02ba\7v\2\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7f\2\2\u02bc") + buf.write("V\3\2\2\2\u02bd\u02be\7g\2\2\u02be\u02bf\7p\2\2\u02bf") + buf.write("\u02c0\7f\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2\7q\2\2\u02c2") + buf.write("\u02c3\7t\2\2\u02c3\u02c4\7o\2\2\u02c4\u02c5\7u\2\2\u02c5") + buf.write("\u02c6\7g\2\2\u02c6\u02c7\7v\2\2\u02c7X\3\2\2\2\u02c8") + buf.write("\u02c9\7v\2\2\u02c9\u02ca\7k\2\2\u02ca\u02cb\7v\2\2\u02cb") + buf.write("\u02cc\7n\2\2\u02cc\u02cd\7g\2\2\u02cdZ\3\2\2\2\u02ce") + buf.write("\u02cf\7h\2\2\u02cf\u02d0\7q\2\2\u02d0\u02d1\7t\2\2\u02d1") + buf.write("\u02d2\7o\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d4\7f\2\2\u02d4") + buf.write("\\\3\2\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7p\2\2\u02d7") + buf.write("\u02d8\7g\2\2\u02d8\u02d9\7q\2\2\u02d9\u02da\7h\2\2\u02da") + buf.write("^\3\2\2\2\u02db\u02dc\7g\2\2\u02dc\u02dd\7p\2\2\u02dd") + buf.write("\u02de\7f\2\2\u02de\u02df\7q\2\2\u02df\u02e0\7p\2\2\u02e0") + buf.write("\u02e1\7g\2\2\u02e1\u02e2\7q\2\2\u02e2\u02e3\7h\2\2\u02e3") + buf.write("`\3\2\2\2\u02e4\u02e5\7r\2\2\u02e5\u02e6\7t\2\2\u02e6") + buf.write("\u02e7\7q\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7r\2\2\u02e9") + buf.write("\u02ea\7v\2\2\u02eab\3\2\2\2\u02eb\u02ec\7q\2\2\u02ec") + buf.write("\u02ed\7t\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef\7g\2\2\u02ef") + buf.write("\u02f0\7t\2\2\u02f0\u02f1\7g\2\2\u02f1\u02f2\7f\2\2\u02f2") + buf.write("\u02f3\7n\2\2\u02f3\u02f4\7k\2\2\u02f4\u02f5\7u\2\2\u02f5") + buf.write("\u02f6\7v\2\2\u02f6d\3\2\2\2\u02f7\u02f8\7o\2\2\u02f8") + buf.write("\u02f9\7c\2\2\u02f9\u02fa\7z\2\2\u02fa\u02fb\7e\2\2\u02fb") + buf.write("\u02fc\7q\2\2\u02fc\u02fd\7p\2\2\u02fd\u02fe\7v\2\2\u02fe") + buf.write("\u02ff\7c\2\2\u02ff\u0300\7k\2\2\u0300\u0301\7p\2\2\u0301") + buf.write("\u0302\7g\2\2\u0302\u0303\7t\2\2\u0303\u0304\7u\2\2\u0304") + buf.write("f\3\2\2\2\u0305\u0306\7g\2\2\u0306\u0307\7p\2\2\u0307") + buf.write("\u0308\7f\2\2\u0308\u0309\7n\2\2\u0309\u030a\7k\2\2\u030a") + buf.write("\u030b\7u\2\2\u030b\u030c\7v\2\2\u030ch\3\2\2\2\u030d") + buf.write("\u030e\7g\2\2\u030e\u030f\7p\2\2\u030f\u0310\7f\2\2\u0310") + buf.write("\u0311\7h\2\2\u0311\u0312\7q\2\2\u0312\u0313\7t\2\2\u0313") + buf.write("\u0314\7o\2\2\u0314j\3\2\2\2\u0315\u0316\7h\2\2\u0316") + buf.write("\u0317\7q\2\2\u0317\u0318\7t\2\2\u0318\u0319\7o\2\2\u0319") + buf.write("l\3\2\2\2\u031a\u031b\7h\2\2\u031b\u031c\7q\2\2\u031c") + buf.write("\u031d\7t\2\2\u031d\u031e\7o\2\2\u031e\u031f\7o\2\2\u031f") + buf.write("\u0320\7c\2\2\u0320\u0321\7r\2\2\u0321n\3\2\2\2\u0322") + buf.write("\u0323\7o\2\2\u0323\u0324\7c\2\2\u0324\u0325\7r\2\2\u0325") + buf.write("\u0326\7v\2\2\u0326\u0327\7k\2\2\u0327\u0328\7v\2\2\u0328") + buf.write("\u0329\7n\2\2\u0329\u032a\7g\2\2\u032ap\3\2\2\2\u032b") + buf.write("\u032c\7o\2\2\u032c\u032d\7c\2\2\u032d\u032e\7r\2\2\u032e") + buf.write("\u032f\7i\2\2\u032f\u0330\7w\2\2\u0330\u0331\7k\2\2\u0331") + buf.write("\u0332\7f\2\2\u0332r\3\2\2\2\u0333\u0334\7u\2\2\u0334") + buf.write("\u0335\7w\2\2\u0335\u0336\7d\2\2\u0336\u0337\7v\2\2\u0337") + buf.write("\u0338\7k\2\2\u0338\u0339\7v\2\2\u0339\u033a\7n\2\2\u033a") + buf.write("\u033b\7g\2\2\u033bt\3\2\2\2\u033c\u033d\7g\2\2\u033d") + buf.write("\u033e\7p\2\2\u033e\u033f\7f\2\2\u033f\u0340\7u\2\2\u0340") + buf.write("\u0341\7w\2\2\u0341\u0342\7d\2\2\u0342\u0343\7v\2\2\u0343") + buf.write("\u0344\7k\2\2\u0344\u0345\7v\2\2\u0345\u0346\7n\2\2\u0346") + buf.write("\u0347\7g\2\2\u0347v\3\2\2\2\u0348\u0349\7j\2\2\u0349") + buf.write("\u034a\7g\2\2\u034a\u034b\7n\2\2\u034b\u034c\7r\2\2\u034c") + buf.write("x\3\2\2\2\u034d\u034e\7v\2\2\u034e\u034f\7g\2\2\u034f") + buf.write("\u0350\7z\2\2\u0350\u0351\7v\2\2\u0351z\3\2\2\2\u0352") + buf.write("\u0353\7q\2\2\u0353\u0354\7r\2\2\u0354\u0355\7v\2\2\u0355") + buf.write("\u0356\7k\2\2\u0356\u0357\7q\2\2\u0357\u0358\7p\2\2\u0358") + buf.write("|\3\2\2\2\u0359\u035a\7h\2\2\u035a\u035b\7n\2\2\u035b") + buf.write("\u035c\7c\2\2\u035c\u035d\7i\2\2\u035d\u035e\7u\2\2\u035e") + buf.write("~\3\2\2\2\u035f\u0360\7f\2\2\u0360\u0361\7c\2\2\u0361") + buf.write("\u0362\7v\2\2\u0362\u0363\7g\2\2\u0363\u0080\3\2\2\2\u0364") + buf.write("\u0365\7g\2\2\u0365\u0366\7p\2\2\u0366\u0367\7f\2\2\u0367") + buf.write("\u0368\7f\2\2\u0368\u0369\7c\2\2\u0369\u036a\7v\2\2\u036a") + buf.write("\u036b\7g\2\2\u036b\u0082\3\2\2\2\u036c\u036d\7{\2\2\u036d") + buf.write("\u036e\7g\2\2\u036e\u036f\7c\2\2\u036f\u0370\7t\2\2\u0370") + buf.write("\u0084\3\2\2\2\u0371\u0372\7o\2\2\u0372\u0373\7q\2\2\u0373") + buf.write("\u0374\7p\2\2\u0374\u0375\7v\2\2\u0375\u0376\7j\2\2\u0376") + buf.write("\u0086\3\2\2\2\u0377\u0378\7f\2\2\u0378\u0379\7c\2\2\u0379") + buf.write("\u037a\7{\2\2\u037a\u0088\3\2\2\2\u037b\u037c\7v\2\2\u037c") + buf.write("\u037d\7k\2\2\u037d\u037e\7o\2\2\u037e\u037f\7g\2\2\u037f") + buf.write("\u008a\3\2\2\2\u0380\u0381\7g\2\2\u0381\u0382\7p\2\2\u0382") + buf.write("\u0383\7f\2\2\u0383\u0384\7v\2\2\u0384\u0385\7k\2\2\u0385") + buf.write("\u0386\7o\2\2\u0386\u0387\7g\2\2\u0387\u008c\3\2\2\2\u0388") + buf.write("\u0389\7j\2\2\u0389\u038a\7q\2\2\u038a\u038b\7w\2\2\u038b") + buf.write("\u038c\7t\2\2\u038c\u008e\3\2\2\2\u038d\u038e\7o\2\2\u038e") + buf.write("\u038f\7k\2\2\u038f\u0390\7p\2\2\u0390\u0391\7w\2\2\u0391") + buf.write("\u0392\7v\2\2\u0392\u0393\7g\2\2\u0393\u0090\3\2\2\2\u0394") + buf.write("\u0395\7u\2\2\u0395\u0396\7g\2\2\u0396\u0397\7e\2\2\u0397") + buf.write("\u0398\7q\2\2\u0398\u0399\7p\2\2\u0399\u039a\7f\2\2\u039a") + buf.write("\u0092\3\2\2\2\u039b\u039c\7i\2\2\u039c\u039d\7t\2\2\u039d") + buf.write("\u039e\7c\2\2\u039e\u039f\7{\2\2\u039f\u03a0\7q\2\2\u03a0") + buf.write("\u03a1\7w\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7k\2\2\u03a3") + buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a6") + buf.write("\u03a7\7c\2\2\u03a7\u03a8\7d\2\2\u03a8\u03a9\7g\2\2\u03a9") + buf.write("\u03aa\7n\2\2\u03aa\u0096\3\2\2\2\u03ab\u03ac\7v\2\2\u03ac") + buf.write("\u03ad\7k\2\2\u03ad\u03ae\7o\2\2\u03ae\u03af\7g\2\2\u03af") + buf.write("\u03b0\7q\2\2\u03b0\u03b1\7w\2\2\u03b1\u03b2\7v\2\2\u03b2") + buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03b5") + buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b8") + buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03bb") + buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03be") + buf.write("\u03bf\7P\2\2\u03bf\u03c0\7Q\2\2\u03c0\u03c1\7P\2\2\u03c1") + buf.write("\u03c2\7a\2\2\u03c2\u03c3\7P\2\2\u03c3\u03c4\7X\2\2\u03c4") + buf.write("\u03c5\7a\2\2\u03c5\u03c6\7F\2\2\u03c6\u03c7\7C\2\2\u03c7") + buf.write("\u03c8\7V\2\2\u03c8\u03c9\7C\2\2\u03c9\u03ca\7a\2\2\u03ca") + buf.write("\u03cb\7O\2\2\u03cb\u03cc\7C\2\2\u03cc\u03cd\7R\2\2\u03cd") + buf.write("\u009c\3\2\2\2\u03ce\u03cf\7u\2\2\u03cf\u03d0\7v\2\2\u03d0") + buf.write("\u03d1\7t\2\2\u03d1\u03d2\7w\2\2\u03d2\u03d3\7e\2\2\u03d3") + buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03d6") + buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d9") + buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03dc") + buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03df") + buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e2") + buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03e5") + buf.write("\u03e6\7P\2\2\u03e6\u03e7\7V\2\2\u03e7\u03e8\78\2\2\u03e8") + buf.write("\u03e9\7\66\2\2\u03e9\u00a4\3\2\2\2\u03ea\u03eb\7W\2\2") + buf.write("\u03eb\u03ec\7K\2\2\u03ec\u03ed\7P\2\2\u03ed\u03ee\7V") + buf.write("\2\2\u03ee\u03ef\7\65\2\2\u03ef\u03f0\7\64\2\2\u03f0\u00a6") + buf.write("\3\2\2\2\u03f1\u03f2\7W\2\2\u03f2\u03f3\7K\2\2\u03f3\u03f4") + buf.write("\7P\2\2\u03f4\u03f5\7V\2\2\u03f5\u03f6\7\63\2\2\u03f6") + buf.write("\u03f7\78\2\2\u03f7\u00a8\3\2\2\2\u03f8\u03f9\7W\2\2\u03f9") + buf.write("\u03fa\7K\2\2\u03fa\u03fb\7P\2\2\u03fb\u03fc\7V\2\2\u03fc") + buf.write("\u03fd\7:\2\2\u03fd\u00aa\3\2\2\2\u03fe\u03ff\7G\2\2\u03ff") + buf.write("\u0400\7H\2\2\u0400\u0401\7K\2\2\u0401\u0402\7a\2\2\u0402") + buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u0405") + buf.write("\u0406\7K\2\2\u0406\u0407\7P\2\2\u0407\u0408\7I\2\2\u0408") + buf.write("\u0409\7a\2\2\u0409\u040a\7K\2\2\u040a\u040b\7F\2\2\u040b") + buf.write("\u00ac\3\2\2\2\u040c\u040d\7G\2\2\u040d\u040e\7H\2\2\u040e") + buf.write("\u040f\7K\2\2\u040f\u0410\7a\2\2\u0410\u0411\7J\2\2\u0411") + buf.write("\u0412\7K\2\2\u0412\u0413\7K\2\2\u0413\u0414\7a\2\2\u0414") + buf.write("\u0415\7F\2\2\u0415\u0416\7C\2\2\u0416\u0417\7V\2\2\u0417") + buf.write("\u0418\7G\2\2\u0418\u00ae\3\2\2\2\u0419\u041a\7G\2\2\u041a") + buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041d") + buf.write("\u041e\7J\2\2\u041e\u041f\7K\2\2\u041f\u0420\7K\2\2\u0420") + buf.write("\u0421\7a\2\2\u0421\u0422\7V\2\2\u0422\u0423\7K\2\2\u0423") + buf.write("\u0424\7O\2\2\u0424\u0425\7G\2\2\u0425\u00b0\3\2\2\2\u0426") + buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u0429") + buf.write("\u042a\7a\2\2\u042a\u042b\7J\2\2\u042b\u042c\7K\2\2\u042c") + buf.write("\u042d\7K\2\2\u042d\u042e\7a\2\2\u042e\u042f\7T\2\2\u042f") + buf.write("\u0430\7G\2\2\u0430\u0431\7H\2\2\u0431\u00b2\3\2\2\2\u0432") + buf.write("\u0433\7i\2\2\u0433\u0434\7w\2\2\u0434\u0435\7k\2\2\u0435") + buf.write("\u0436\7f\2\2\u0436\u00b4\3\2\2\2\u0437\u0438\7e\2\2\u0438") + buf.write("\u0439\7j\2\2\u0439\u043a\7g\2\2\u043a\u043b\7e\2\2\u043b") + buf.write("\u043c\7m\2\2\u043c\u043d\7d\2\2\u043d\u043e\7q\2\2\u043e") + buf.write("\u043f\7z\2\2\u043f\u00b6\3\2\2\2\u0440\u0441\7g\2\2\u0441") + buf.write("\u0442\7p\2\2\u0442\u0443\7f\2\2\u0443\u0444\7e\2\2\u0444") + buf.write("\u0445\7j\2\2\u0445\u0446\7g\2\2\u0446\u0447\7e\2\2\u0447") + buf.write("\u0448\7m\2\2\u0448\u0449\7d\2\2\u0449\u044a\7q\2\2\u044a") + buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044d") + buf.write("\u044e\7w\2\2\u044e\u044f\7o\2\2\u044f\u0450\7g\2\2\u0450") + buf.write("\u0451\7t\2\2\u0451\u0452\7k\2\2\u0452\u0453\7e\2\2\u0453") + buf.write("\u00ba\3\2\2\2\u0454\u0455\7g\2\2\u0455\u0456\7p\2\2\u0456") + buf.write("\u0457\7f\2\2\u0457\u0458\7p\2\2\u0458\u0459\7w\2\2\u0459") + buf.write("\u045a\7o\2\2\u045a\u045b\7g\2\2\u045b\u045c\7t\2\2\u045c") + buf.write("\u045d\7k\2\2\u045d\u045e\7e\2\2\u045e\u00bc\3\2\2\2\u045f") + buf.write("\u0460\7o\2\2\u0460\u0461\7k\2\2\u0461\u0462\7p\2\2\u0462") + buf.write("\u0463\7k\2\2\u0463\u0464\7o\2\2\u0464\u0465\7w\2\2\u0465") + buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u0468") + buf.write("\u0469\7c\2\2\u0469\u046a\7z\2\2\u046a\u046b\7k\2\2\u046b") + buf.write("\u046c\7o\2\2\u046c\u046d\7w\2\2\u046d\u046e\7o\2\2\u046e") + buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u0471") + buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u0474") + buf.write("\u0475\7f\2\2\u0475\u0476\7g\2\2\u0476\u0477\7h\2\2\u0477") + buf.write("\u0478\7c\2\2\u0478\u0479\7w\2\2\u0479\u047a\7n\2\2\u047a") + buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047d") + buf.write("\u047e\7c\2\2\u047e\u047f\7u\2\2\u047f\u0480\7u\2\2\u0480") + buf.write("\u0481\7y\2\2\u0481\u0482\7q\2\2\u0482\u0483\7t\2\2\u0483") + buf.write("\u0484\7f\2\2\u0484\u00c6\3\2\2\2\u0485\u0486\7g\2\2\u0486") + buf.write("\u0487\7p\2\2\u0487\u0488\7f\2\2\u0488\u0489\7r\2\2\u0489") + buf.write("\u048a\7c\2\2\u048a\u048b\7u\2\2\u048b\u048c\7u\2\2\u048c") + buf.write("\u048d\7y\2\2\u048d\u048e\7q\2\2\u048e\u048f\7t\2\2\u048f") + buf.write("\u0490\7f\2\2\u0490\u00c8\3\2\2\2\u0491\u0492\7u\2\2\u0492") + buf.write("\u0493\7v\2\2\u0493\u0494\7t\2\2\u0494\u0495\7k\2\2\u0495") + buf.write("\u0496\7p\2\2\u0496\u0497\7i\2\2\u0497\u00ca\3\2\2\2\u0498") + buf.write("\u0499\7g\2\2\u0499\u049a\7p\2\2\u049a\u049b\7f\2\2\u049b") + buf.write("\u049c\7u\2\2\u049c\u049d\7v\2\2\u049d\u049e\7t\2\2\u049e") + buf.write("\u049f\7k\2\2\u049f\u04a0\7p\2\2\u04a0\u04a1\7i\2\2\u04a1") + buf.write("\u00cc\3\2\2\2\u04a2\u04a3\7o\2\2\u04a3\u04a4\7k\2\2\u04a4") + buf.write("\u04a5\7p\2\2\u04a5\u04a6\7u\2\2\u04a6\u04a7\7k\2\2\u04a7") + buf.write("\u04a8\7|\2\2\u04a8\u04a9\7g\2\2\u04a9\u00ce\3\2\2\2\u04aa") + buf.write("\u04ab\7o\2\2\u04ab\u04ac\7c\2\2\u04ac\u04ad\7z\2\2\u04ad") + buf.write("\u04ae\7u\2\2\u04ae\u04af\7k\2\2\u04af\u04b0\7|\2\2\u04b0") + buf.write("\u04b1\7g\2\2\u04b1\u00d0\3\2\2\2\u04b2\u04b3\7g\2\2\u04b3") + buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b6") + buf.write("\u04b7\7f\2\2\u04b7\u04b8\7k\2\2\u04b8\u04b9\7p\2\2\u04b9") + buf.write("\u04ba\7i\2\2\u04ba\u00d2\3\2\2\2\u04bb\u04bc\7u\2\2\u04bc") + buf.write("\u04bd\7w\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\7r\2\2\u04bf") + buf.write("\u04c0\7t\2\2\u04c0\u04c1\7g\2\2\u04c1\u04c2\7u\2\2\u04c2") + buf.write("\u04c3\7u\2\2\u04c3\u04c4\7k\2\2\u04c4\u04c5\7h\2\2\u04c5") + buf.write("\u00d4\3\2\2\2\u04c6\u04c7\7f\2\2\u04c7\u04c8\7k\2\2\u04c8") + buf.write("\u04c9\7u\2\2\u04c9\u04ca\7c\2\2\u04ca\u04cb\7d\2\2\u04cb") + buf.write("\u04cc\7n\2\2\u04cc\u04cd\7g\2\2\u04cd\u04ce\7k\2\2\u04ce") + buf.write("\u04cf\7h\2\2\u04cf\u00d6\3\2\2\2\u04d0\u04d1\7j\2\2\u04d1") + buf.write("\u04d2\7k\2\2\u04d2\u04d3\7f\2\2\u04d3\u04d4\7f\2\2\u04d4") + buf.write("\u04d5\7g\2\2\u04d5\u04d6\7p\2\2\u04d6\u00d8\3\2\2\2\u04d7") + buf.write("\u04d8\7i\2\2\u04d8\u04d9\7q\2\2\u04d9\u04da\7v\2\2\u04da") + buf.write("\u04db\7q\2\2\u04db\u00da\3\2\2\2\u04dc\u04dd\7h\2\2\u04dd") + buf.write("\u04de\7q\2\2\u04de\u04df\7t\2\2\u04df\u04e0\7o\2\2\u04e0") + buf.write("\u04e1\7u\2\2\u04e1\u04e2\7g\2\2\u04e2\u04e3\7v\2\2\u04e3") + buf.write("\u04e4\7i\2\2\u04e4\u04e5\7w\2\2\u04e5\u04e6\7k\2\2\u04e6") + buf.write("\u04e7\7f\2\2\u04e7\u00dc\3\2\2\2\u04e8\u04e9\7k\2\2\u04e9") + buf.write("\u04ea\7p\2\2\u04ea\u04eb\7e\2\2\u04eb\u04ec\7q\2\2\u04ec") + buf.write("\u04ed\7p\2\2\u04ed\u04ee\7u\2\2\u04ee\u04ef\7k\2\2\u04ef") + buf.write("\u04f0\7u\2\2\u04f0\u04f1\7v\2\2\u04f1\u04f2\7g\2\2\u04f2") + buf.write("\u04f3\7p\2\2\u04f3\u04f4\7v\2\2\u04f4\u04f5\7k\2\2\u04f5") + buf.write("\u04f6\7h\2\2\u04f6\u00de\3\2\2\2\u04f7\u04f8\7y\2\2\u04f8") + buf.write("\u04f9\7c\2\2\u04f9\u04fa\7t\2\2\u04fa\u04fb\7p\2\2\u04fb") + buf.write("\u04fc\7k\2\2\u04fc\u04fd\7p\2\2\u04fd\u04fe\7i\2\2\u04fe") + buf.write("\u04ff\7k\2\2\u04ff\u0500\7h\2\2\u0500\u00e0\3\2\2\2\u0501") + buf.write("\u0502\7p\2\2\u0502\u0503\7q\2\2\u0503\u0504\7u\2\2\u0504") + buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u0507") + buf.write("\u0508\7k\2\2\u0508\u0509\7v\2\2\u0509\u050a\7k\2\2\u050a") + buf.write("\u050b\7h\2\2\u050b\u00e2\3\2\2\2\u050c\u050d\7g\2\2\u050d") + buf.write("\u050e\7p\2\2\u050e\u050f\7f\2\2\u050f\u0510\7k\2\2\u0510") + buf.write("\u0511\7h\2\2\u0511\u00e4\3\2\2\2\u0512\u0513\7m\2\2\u0513") + buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u0516") + buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u0519") + buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051c") + buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051f") + buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u0522") + buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u0525") + buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u0528") + buf.write("\u0529\7K\2\2\u0529\u052a\7P\2\2\u052a\u052b\7I\2\2\u052b") + buf.write("\u00ea\3\2\2\2\u052c\u052d\7E\2\2\u052d\u052e\7J\2\2\u052e") + buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u0531") + buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u0534") + buf.write("\u0535\7a\2\2\u0535\u0536\7F\2\2\u0536\u0537\7G\2\2\u0537") + buf.write("\u0538\7H\2\2\u0538\u0539\7C\2\2\u0539\u053a\7W\2\2\u053a") + buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053d") + buf.write("\u053e\7E\2\2\u053e\u053f\7J\2\2\u053f\u0540\7G\2\2\u0540") + buf.write("\u0541\7E\2\2\u0541\u0542\7M\2\2\u0542\u0543\7D\2\2\u0543") + buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u0546") + buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u0549") + buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054c") + buf.write("\u054d\7V\2\2\u054d\u054e\7a\2\2\u054e\u054f\7O\2\2\u054f") + buf.write("\u0550\7H\2\2\u0550\u0551\7I\2\2\u0551\u00ee\3\2\2\2\u0552") + buf.write("\u0553\7K\2\2\u0553\u0554\7P\2\2\u0554\u0555\7V\2\2\u0555") + buf.write("\u0556\7G\2\2\u0556\u0557\7T\2\2\u0557\u0558\7C\2\2\u0558") + buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055b") + buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055e") + buf.write("\u055f\7P\2\2\u055f\u0560\7X\2\2\u0560\u0561\7a\2\2\u0561") + buf.write("\u0562\7C\2\2\u0562\u0563\7E\2\2\u0563\u0564\7E\2\2\u0564") + buf.write("\u0565\7G\2\2\u0565\u0566\7U\2\2\u0566\u0567\7U\2\2\u0567") + buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056a") + buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056d") + buf.write("\u056e\7a\2\2\u056e\u056f\7T\2\2\u056f\u0570\7G\2\2\u0570") + buf.write("\u0571\7S\2\2\u0571\u0572\7W\2\2\u0572\u0573\7K\2\2\u0573") + buf.write("\u0574\7T\2\2\u0574\u0575\7G\2\2\u0575\u0576\7F\2\2\u0576") + buf.write("\u00f4\3\2\2\2\u0577\u0578\7T\2\2\u0578\u0579\7G\2\2\u0579") + buf.write("\u057a\7E\2\2\u057a\u057b\7Q\2\2\u057b\u057c\7P\2\2\u057c") + buf.write("\u057d\7P\2\2\u057d\u057e\7G\2\2\u057e\u057f\7E\2\2\u057f") + buf.write("\u0580\7V\2\2\u0580\u0581\7a\2\2\u0581\u0582\7T\2\2\u0582") + buf.write("\u0583\7G\2\2\u0583\u0584\7S\2\2\u0584\u0585\7W\2\2\u0585") + buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u0588") + buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058b") + buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058e") + buf.write("\u058f\7a\2\2\u058f\u0590\7E\2\2\u0590\u0591\7J\2\2\u0591") + buf.write("\u0592\7G\2\2\u0592\u0593\7E\2\2\u0593\u0594\7M\2\2\u0594") + buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u0597") + buf.write("\u0598\7C\2\2\u0598\u0599\7F\2\2\u0599\u059a\7a\2\2\u059a") + buf.write("\u059b\7Q\2\2\u059b\u059c\7P\2\2\u059c\u059d\7N\2\2\u059d") + buf.write("\u059e\7[\2\2\u059e\u00fa\3\2\2\2\u059f\u05a0\7Q\2\2\u05a0") + buf.write("\u05a1\7R\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a3\7K\2\2\u05a3") + buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a6") + buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a9") + buf.write("\u05aa\7N\2\2\u05aa\u05ab\7[\2\2\u05ab\u00fc\3\2\2\2\u05ac") + buf.write("\u05ad\7T\2\2\u05ad\u05ae\7G\2\2\u05ae\u05af\7U\2\2\u05af") + buf.write("\u05b0\7V\2\2\u05b0\u05b1\7a\2\2\u05b1\u05b2\7U\2\2\u05b2") + buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b5") + buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b8") + buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05bb") + buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05be") + buf.write("\u05bf\7w\2\2\u05bf\u05c0\7d\2\2\u05c0\u05c1\7e\2\2\u05c1") + buf.write("\u05c2\7n\2\2\u05c2\u05c3\7c\2\2\u05c3\u05c4\7u\2\2\u05c4") + buf.write("\u05c5\7u\2\2\u05c5\u0102\3\2\2\2\u05c6\u05c7\7e\2\2\u05c7") + buf.write("\u05c8\7n\2\2\u05c8\u05c9\7c\2\2\u05c9\u05ca\7u\2\2\u05ca") + buf.write("\u05cb\7u\2\2\u05cb\u05cc\7i\2\2\u05cc\u05cd\7w\2\2\u05cd") + buf.write("\u05ce\7k\2\2\u05ce\u05cf\7f\2\2\u05cf\u0104\3\2\2\2\u05d0") + buf.write("\u05d1\7v\2\2\u05d1\u05d2\7{\2\2\u05d2\u05d3\7r\2\2\u05d3") + buf.write("\u05d4\7g\2\2\u05d4\u05d5\7f\2\2\u05d5\u05d6\7g\2\2\u05d6") + buf.write("\u05d7\7h\2\2\u05d7\u0106\3\2\2\2\u05d8\u05d9\7t\2\2\u05d9") + buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05dc") + buf.write("\u05dd\7q\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7g\2\2\u05df") + buf.write("\u0108\3\2\2\2\u05e0\u05e1\7u\2\2\u05e1\u05e2\7c\2\2\u05e2") + buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e5") + buf.write("\u05e6\7f\2\2\u05e6\u05e7\7g\2\2\u05e7\u05e8\7h\2\2\u05e8") + buf.write("\u05e9\7c\2\2\u05e9\u05ea\7w\2\2\u05ea\u05eb\7n\2\2\u05eb") + buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05ee") + buf.write("\u05ef\7d\2\2\u05ef\u05f0\7c\2\2\u05f0\u05f1\7p\2\2\u05f1") + buf.write("\u05f2\7p\2\2\u05f2\u05f3\7g\2\2\u05f3\u05f4\7t\2\2\u05f4") + buf.write("\u010e\3\2\2\2\u05f5\u05f6\7c\2\2\u05f6\u05f7\7n\2\2\u05f7") + buf.write("\u05f8\7k\2\2\u05f8\u05f9\7i\2\2\u05f9\u05fa\7p\2\2\u05fa") + buf.write("\u0110\3\2\2\2\u05fb\u05fc\7n\2\2\u05fc\u05fd\7g\2\2\u05fd") + buf.write("\u05fe\7h\2\2\u05fe\u05ff\7v\2\2\u05ff\u0112\3\2\2\2\u0600") + buf.write("\u0601\7t\2\2\u0601\u0602\7k\2\2\u0602\u0603\7i\2\2\u0603") + buf.write("\u0604\7j\2\2\u0604\u0605\7v\2\2\u0605\u0114\3\2\2\2\u0606") + buf.write("\u0607\7e\2\2\u0607\u0608\7g\2\2\u0608\u0609\7p\2\2\u0609") + buf.write("\u060a\7v\2\2\u060a\u060b\7g\2\2\u060b\u060c\7t\2\2\u060c") + buf.write("\u0116\3\2\2\2\u060d\u060e\7n\2\2\u060e\u060f\7k\2\2\u060f") + buf.write("\u0610\7p\2\2\u0610\u0611\7g\2\2\u0611\u0118\3\2\2\2\u0612") + buf.write("\u0613\7p\2\2\u0613\u0614\7c\2\2\u0614\u0615\7o\2\2\u0615") + buf.write("\u0616\7g\2\2\u0616\u011a\3\2\2\2\u0617\u0618\7x\2\2\u0618") + buf.write("\u0619\7c\2\2\u0619\u061a\7t\2\2\u061a\u061b\7k\2\2\u061b") + buf.write("\u061c\7f\2\2\u061c\u011c\3\2\2\2\u061d\u061e\7s\2\2\u061e") + buf.write("\u061f\7w\2\2\u061f\u0620\7g\2\2\u0620\u0621\7u\2\2\u0621") + buf.write("\u0622\7v\2\2\u0622\u0623\7k\2\2\u0623\u0624\7q\2\2\u0624") + buf.write("\u0625\7p\2\2\u0625\u011e\3\2\2\2\u0626\u0627\7s\2\2\u0627") + buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062a") + buf.write("\u062b\7v\2\2\u062b\u062c\7k\2\2\u062c\u062d\7q\2\2\u062d") + buf.write("\u062e\7p\2\2\u062e\u062f\7k\2\2\u062f\u0630\7f\2\2\u0630") + buf.write("\u0120\3\2\2\2\u0631\u0632\7k\2\2\u0632\u0633\7o\2\2\u0633") + buf.write("\u0634\7c\2\2\u0634\u0635\7i\2\2\u0635\u0636\7g\2\2\u0636") + buf.write("\u0122\3\2\2\2\u0637\u0638\7n\2\2\u0638\u0639\7q\2\2\u0639") + buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063c") + buf.write("\u063d\7f\2\2\u063d\u0124\3\2\2\2\u063e\u063f\7t\2\2\u063f") + buf.write("\u0640\7w\2\2\u0640\u0641\7n\2\2\u0641\u0642\7g\2\2\u0642") + buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u0645") + buf.write("\u0646\7f\2\2\u0646\u0647\7t\2\2\u0647\u0648\7w\2\2\u0648") + buf.write("\u0649\7n\2\2\u0649\u064a\7g\2\2\u064a\u0128\3\2\2\2\u064b") + buf.write("\u064c\7x\2\2\u064c\u064d\7c\2\2\u064d\u064e\7n\2\2\u064e") + buf.write("\u064f\7w\2\2\u064f\u0650\7g\2\2\u0650\u012a\3\2\2\2\u0651") + buf.write("\u0652\7t\2\2\u0652\u0653\7g\2\2\u0653\u0654\7c\2\2\u0654") + buf.write("\u0655\7f\2\2\u0655\u012c\3\2\2\2\u0656\u0657\7y\2\2\u0657") + buf.write("\u0658\7t\2\2\u0658\u0659\7k\2\2\u0659\u065a\7v\2\2\u065a") + buf.write("\u065b\7g\2\2\u065b\u012e\3\2\2\2\u065c\u065d\7t\2\2\u065d") + buf.write("\u065e\7g\2\2\u065e\u065f\7u\2\2\u065f\u0660\7g\2\2\u0660") + buf.write("\u0661\7v\2\2\u0661\u0662\7d\2\2\u0662\u0663\7w\2\2\u0663") + buf.write("\u0664\7v\2\2\u0664\u0665\7v\2\2\u0665\u0666\7q\2\2\u0666") + buf.write("\u0667\7p\2\2\u0667\u0130\3\2\2\2\u0668\u0669\7g\2\2\u0669") + buf.write("\u066a\7p\2\2\u066a\u066b\7f\2\2\u066b\u066c\7t\2\2\u066c") + buf.write("\u066d\7g\2\2\u066d\u066e\7u\2\2\u066e\u066f\7g\2\2\u066f") + buf.write("\u0670\7v\2\2\u0670\u0671\7d\2\2\u0671\u0672\7w\2\2\u0672") + buf.write("\u0673\7v\2\2\u0673\u0674\7v\2\2\u0674\u0675\7q\2\2\u0675") + buf.write("\u0676\7p\2\2\u0676\u0132\3\2\2\2\u0677\u0678\7f\2\2\u0678") + buf.write("\u0679\7g\2\2\u0679\u067a\7h\2\2\u067a\u067b\7c\2\2\u067b") + buf.write("\u067c\7w\2\2\u067c\u067d\7n\2\2\u067d\u067e\7v\2\2\u067e") + buf.write("\u067f\7u\2\2\u067f\u0680\7v\2\2\u0680\u0681\7q\2\2\u0681") + buf.write("\u0682\7t\2\2\u0682\u0683\7g\2\2\u0683\u0134\3\2\2\2\u0684") + buf.write("\u0685\7c\2\2\u0685\u0686\7v\2\2\u0686\u0687\7v\2\2\u0687") + buf.write("\u0688\7t\2\2\u0688\u0689\7k\2\2\u0689\u068a\7d\2\2\u068a") + buf.write("\u068b\7w\2\2\u068b\u068c\7v\2\2\u068c\u068d\7g\2\2\u068d") + buf.write("\u0136\3\2\2\2\u068e\u068f\7x\2\2\u068f\u0690\7c\2\2\u0690") + buf.write("\u0691\7t\2\2\u0691\u0692\7u\2\2\u0692\u0693\7v\2\2\u0693") + buf.write("\u0694\7q\2\2\u0694\u0695\7t\2\2\u0695\u0696\7g\2\2\u0696") + buf.write("\u0138\3\2\2\2\u0697\u0698\7g\2\2\u0698\u0699\7h\2\2\u0699") + buf.write("\u069a\7k\2\2\u069a\u069b\7x\2\2\u069b\u069c\7c\2\2\u069c") + buf.write("\u069d\7t\2\2\u069d\u069e\7u\2\2\u069e\u069f\7v\2\2\u069f") + buf.write("\u06a0\7q\2\2\u06a0\u06a1\7t\2\2\u06a1\u06a2\7g\2\2\u06a2") + buf.write("\u013a\3\2\2\2\u06a3\u06a4\7x\2\2\u06a4\u06a5\7c\2\2\u06a5") + buf.write("\u06a6\7t\2\2\u06a6\u06a7\7u\2\2\u06a7\u06a8\7k\2\2\u06a8") + buf.write("\u06a9\7|\2\2\u06a9\u06aa\7g\2\2\u06aa\u013c\3\2\2\2\u06ab") + buf.write("\u06ac\7p\2\2\u06ac\u06ad\7c\2\2\u06ad\u06ae\7o\2\2\u06ae") + buf.write("\u06af\7g\2\2\u06af\u06b0\7x\2\2\u06b0\u06b1\7c\2\2\u06b1") + buf.write("\u06b2\7n\2\2\u06b2\u06b3\7w\2\2\u06b3\u06b4\7g\2\2\u06b4") + buf.write("\u06b5\7x\2\2\u06b5\u06b6\7c\2\2\u06b6\u06b7\7t\2\2\u06b7") + buf.write("\u06b8\7u\2\2\u06b8\u06b9\7v\2\2\u06b9\u06ba\7q\2\2\u06ba") + buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06bd") + buf.write("\u06be\7c\2\2\u06be\u06bf\7e\2\2\u06bf\u06c0\7v\2\2\u06c0") + buf.write("\u06c1\7k\2\2\u06c1\u06c2\7q\2\2\u06c2\u06c3\7p\2\2\u06c3") + buf.write("\u0140\3\2\2\2\u06c4\u06c5\7e\2\2\u06c5\u06c6\7q\2\2\u06c6") + buf.write("\u06c7\7p\2\2\u06c7\u06c8\7h\2\2\u06c8\u06c9\7k\2\2\u06c9") + buf.write("\u06ca\7i\2\2\u06ca\u0142\3\2\2\2\u06cb\u06cc\7g\2\2\u06cc") + buf.write("\u06cd\7p\2\2\u06cd\u06ce\7f\2\2\u06ce\u06cf\7c\2\2\u06cf") + buf.write("\u06d0\7e\2\2\u06d0\u06d1\7v\2\2\u06d1\u06d2\7k\2\2\u06d2") + buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06d5") + buf.write("\u06d6\7t\2\2\u06d6\u06d7\7g\2\2\u06d7\u06d8\7h\2\2\u06d8") + buf.write("\u06d9\7t\2\2\u06d9\u06da\7g\2\2\u06da\u06db\7u\2\2\u06db") + buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06de") + buf.write("\u06df\7p\2\2\u06df\u06e0\7v\2\2\u06e0\u06e1\7g\2\2\u06e1") + buf.write("\u06e2\7t\2\2\u06e2\u06e3\7x\2\2\u06e3\u06e4\7c\2\2\u06e4") + buf.write("\u06e5\7n\2\2\u06e5\u0148\3\2\2\2\u06e6\u06e7\7x\2\2\u06e7") + buf.write("\u06e8\7c\2\2\u06e8\u06e9\7t\2\2\u06e9\u06ea\7u\2\2\u06ea") + buf.write("\u06eb\7v\2\2\u06eb\u06ec\7q\2\2\u06ec\u06ed\7t\2\2\u06ed") + buf.write("\u06ee\7g\2\2\u06ee\u06ef\7f\2\2\u06ef\u06f0\7g\2\2\u06f0") + buf.write("\u06f1\7x\2\2\u06f1\u06f2\7k\2\2\u06f2\u06f3\7e\2\2\u06f3") + buf.write("\u06f4\7g\2\2\u06f4\u014a\3\2\2\2\u06f5\u06f6\7i\2\2\u06f6") + buf.write("\u06f7\7w\2\2\u06f7\u06f8\7k\2\2\u06f8\u06f9\7f\2\2\u06f9") + buf.write("\u06fa\7q\2\2\u06fa\u06fb\7r\2\2\u06fb\u014c\3\2\2\2\u06fc") + buf.write("\u06fd\7g\2\2\u06fd\u06fe\7p\2\2\u06fe\u06ff\7f\2\2\u06ff") + buf.write("\u0700\7i\2\2\u0700\u0701\7w\2\2\u0701\u0702\7k\2\2\u0702") + buf.write("\u0703\7f\2\2\u0703\u0704\7q\2\2\u0704\u0705\7r\2\2\u0705") + buf.write("\u014e\3\2\2\2\u0706\u0707\7f\2\2\u0707\u0708\7c\2\2\u0708") + buf.write("\u0709\7v\2\2\u0709\u070a\7c\2\2\u070a\u070b\7v\2\2\u070b") + buf.write("\u070c\7{\2\2\u070c\u070d\7r\2\2\u070d\u070e\7g\2\2\u070e") + buf.write("\u0150\3\2\2\2\u070f\u0710\7f\2\2\u0710\u0711\7c\2\2\u0711") + buf.write("\u0712\7v\2\2\u0712\u0713\7c\2\2\u0713\u0152\3\2\2\2\u0714") + buf.write("\u0715\7o\2\2\u0715\u0716\7q\2\2\u0716\u0717\7f\2\2\u0717") + buf.write("\u0718\7c\2\2\u0718\u0719\7n\2\2\u0719\u0154\3\2\2\2\u071a") + buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071d") + buf.write("\u071e\7a\2\2\u071e\u071f\7F\2\2\u071f\u0720\7G\2\2\u0720") + buf.write("\u0721\7X\2\2\u0721\u0722\7K\2\2\u0722\u0723\7E\2\2\u0723") + buf.write("\u0724\7G\2\2\u0724\u0156\3\2\2\2\u0725\u0726\7F\2\2\u0726") + buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u0729") + buf.write("\u072a\7a\2\2\u072a\u072b\7F\2\2\u072b\u072c\7G\2\2\u072c") + buf.write("\u072d\7X\2\2\u072d\u072e\7K\2\2\u072e\u072f\7E\2\2\u072f") + buf.write("\u0730\7G\2\2\u0730\u0158\3\2\2\2\u0731\u0732\7X\2\2\u0732") + buf.write("\u0733\7K\2\2\u0733\u0734\7F\2\2\u0734\u0735\7G\2\2\u0735") + buf.write("\u0736\7Q\2\2\u0736\u0737\7a\2\2\u0737\u0738\7F\2\2\u0738") + buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073b") + buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073e") + buf.write("\u073f\7P\2\2\u073f\u0740\7G\2\2\u0740\u0741\7V\2\2\u0741") + buf.write("\u0742\7Y\2\2\u0742\u0743\7Q\2\2\u0743\u0744\7T\2\2\u0744") + buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u0747") + buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074a") + buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074d") + buf.write("\u074e\7K\2\2\u074e\u074f\7P\2\2\u074f\u0750\7R\2\2\u0750") + buf.write("\u0751\7W\2\2\u0751\u0752\7V\2\2\u0752\u0753\7a\2\2\u0753") + buf.write("\u0754\7F\2\2\u0754\u0755\7G\2\2\u0755\u0756\7X\2\2\u0756") + buf.write("\u0757\7K\2\2\u0757\u0758\7E\2\2\u0758\u0759\7G\2\2\u0759") + buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075c") + buf.write("\u075d\7D\2\2\u075d\u075e\7Q\2\2\u075e\u075f\7C\2\2\u075f") + buf.write("\u0760\7T\2\2\u0760\u0761\7F\2\2\u0761\u0762\7a\2\2\u0762") + buf.write("\u0763\7F\2\2\u0763\u0764\7G\2\2\u0764\u0765\7X\2\2\u0765") + buf.write("\u0766\7K\2\2\u0766\u0767\7E\2\2\u0767\u0768\7G\2\2\u0768") + buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u076b") + buf.write("\u076c\7J\2\2\u076c\u076d\7G\2\2\u076d\u076e\7T\2\2\u076e") + buf.write("\u076f\7a\2\2\u076f\u0770\7F\2\2\u0770\u0771\7G\2\2\u0771") + buf.write("\u0772\7X\2\2\u0772\u0773\7K\2\2\u0773\u0774\7E\2\2\u0774") + buf.write("\u0775\7G\2\2\u0775\u0162\3\2\2\2\u0776\u0777\7U\2\2\u0777") + buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u077a") + buf.write("\u077b\7R\2\2\u077b\u077c\7a\2\2\u077c\u077d\7C\2\2\u077d") + buf.write("\u077e\7R\2\2\u077e\u077f\7R\2\2\u077f\u0780\7N\2\2\u0780") + buf.write("\u0781\7K\2\2\u0781\u0782\7E\2\2\u0782\u0783\7C\2\2\u0783") + buf.write("\u0784\7V\2\2\u0784\u0785\7K\2\2\u0785\u0786\7Q\2\2\u0786") + buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u0789") + buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078c") + buf.write("\u078d\7T\2\2\u078d\u078e\7C\2\2\u078e\u078f\7N\2\2\u078f") + buf.write("\u0790\7a\2\2\u0790\u0791\7C\2\2\u0791\u0792\7R\2\2\u0792") + buf.write("\u0793\7R\2\2\u0793\u0794\7N\2\2\u0794\u0795\7K\2\2\u0795") + buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u0798") + buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079b") + buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079e") + buf.write("\u079f\7Q\2\2\u079f\u07a0\7P\2\2\u07a0\u07a1\7V\2\2\u07a1") + buf.write("\u07a2\7a\2\2\u07a2\u07a3\7R\2\2\u07a3\u07a4\7C\2\2\u07a4") + buf.write("\u07a5\7I\2\2\u07a5\u07a6\7G\2\2\u07a6\u0168\3\2\2\2\u07a7") + buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07aa") + buf.write("\u07ab\7I\2\2\u07ab\u07ac\7N\2\2\u07ac\u07ad\7G\2\2\u07ad") + buf.write("\u07ae\7a\2\2\u07ae\u07af\7W\2\2\u07af\u07b0\7U\2\2\u07b0") + buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b3") + buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b6") + buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07b9") + buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07bc") + buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07bf") + buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c2") + buf.write("\u07c3\7P\2\2\u07c3\u07c4\7V\2\2\u07c4\u07c5\7J\2\2\u07c5") + buf.write("\u07c6\7a\2\2\u07c6\u07c7\7U\2\2\u07c7\u07c8\7W\2\2\u07c8") + buf.write("\u07c9\7R\2\2\u07c9\u07ca\7R\2\2\u07ca\u07cb\7T\2\2\u07cb") + buf.write("\u07cc\7G\2\2\u07cc\u07cd\7U\2\2\u07cd\u07ce\7U\2\2\u07ce") + buf.write("\u016e\3\2\2\2\u07cf\u07d0\7F\2\2\u07d0\u07d1\7C\2\2\u07d1") + buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d4") + buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07d7") + buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07da") + buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07dd") + buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e0") + buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e3") + buf.write("\u07e4\7R\2\2\u07e4\u07e5\7R\2\2\u07e5\u07e6\7T\2\2\u07e6") + buf.write("\u07e7\7G\2\2\u07e7\u07e8\7U\2\2\u07e8\u07e9\7U\2\2\u07e9") + buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07ec") + buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07ef") + buf.write("\u07f0\7G\2\2\u07f0\u07f1\7a\2\2\u07f1\u07f2\7U\2\2\u07f2") + buf.write("\u07f3\7W\2\2\u07f3\u07f4\7R\2\2\u07f4\u07f5\7R\2\2\u07f5") + buf.write("\u07f6\7T\2\2\u07f6\u07f7\7G\2\2\u07f7\u07f8\7U\2\2\u07f8") + buf.write("\u07f9\7U\2\2\u07f9\u0174\3\2\2\2\u07fa\u07fb\7U\2\2\u07fb") + buf.write("\u07fc\7G\2\2\u07fc\u07fd\7E\2\2\u07fd\u07fe\7Q\2\2\u07fe") + buf.write("\u07ff\7P\2\2\u07ff\u0800\7F\2\2\u0800\u0801\7a\2\2\u0801") + buf.write("\u0802\7U\2\2\u0802\u0803\7W\2\2\u0803\u0804\7R\2\2\u0804") + buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u0807") + buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u080a") + buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080d") + buf.write("\u080e\7T\2\2\u080e\u080f\7C\2\2\u080f\u0810\7I\2\2\u0810") + buf.write("\u0811\7G\2\2\u0811\u0812\7a\2\2\u0812\u0813\7P\2\2\u0813") + buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u0816") + buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u0819") + buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081c") + buf.write("\u081d\7T\2\2\u081d\u081e\7C\2\2\u081e\u081f\7I\2\2\u081f") + buf.write("\u0820\7G\2\2\u0820\u0821\7a\2\2\u0821\u0822\7V\2\2\u0822") + buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u0825") + buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u0828") + buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082b") + buf.write("\u082c\7I\2\2\u082c\u082d\7G\2\2\u082d\u082e\7a\2\2\u082e") + buf.write("\u082f\7Y\2\2\u082f\u0830\7C\2\2\u0830\u0831\7M\2\2\u0831") + buf.write("\u0832\7G\2\2\u0832\u0833\7W\2\2\u0833\u0834\7R\2\2\u0834") + buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u0837") + buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083a") + buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083d") + buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u0840") + buf.write("\u0841\7R\2\2\u0841\u0842\7V\2\2\u0842\u0843\7[\2\2\u0843") + buf.write("\u0180\3\2\2\2\u0844\u0845\7e\2\2\u0845\u0846\7q\2\2\u0846") + buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u0849") + buf.write("\u084a\7h\2\2\u084a\u084b\7k\2\2\u084b\u084c\7p\2\2\u084c") + buf.write("\u084d\7f\2\2\u084d\u0184\3\2\2\2\u084e\u084f\7o\2\2\u084f") + buf.write("\u0850\7k\2\2\u0850\u0851\7f\2\2\u0851\u0186\3\2\2\2\u0852") + buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u0855") + buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u0858") + buf.write("\u0859\7u\2\2\u0859\u085a\7r\2\2\u085a\u085b\7c\2\2\u085b") + buf.write("\u085c\7p\2\2\u085c\u018a\3\2\2\2\u085d\u085e\7f\2\2\u085e") + buf.write("\u085f\7w\2\2\u085f\u0860\7r\2\2\u0860\u018c\3\2\2\2\u0861") + buf.write("\u0862\7x\2\2\u0862\u0863\7c\2\2\u0863\u0864\7t\2\2\u0864") + buf.write("\u0865\7g\2\2\u0865\u0866\7s\2\2\u0866\u0867\7x\2\2\u0867") + buf.write("\u0868\7c\2\2\u0868\u0869\7n\2\2\u0869\u018e\3\2\2\2\u086a") + buf.write("\u086b\7x\2\2\u086b\u086c\7c\2\2\u086c\u086d\7t\2\2\u086d") + buf.write("\u0190\3\2\2\2\u086e\u086f\7k\2\2\u086f\u0870\7f\2\2\u0870") + buf.write("\u0871\7g\2\2\u0871\u0872\7s\2\2\u0872\u0873\7x\2\2\u0873") + buf.write("\u0874\7c\2\2\u0874\u0875\7n\2\2\u0875\u0192\3\2\2\2\u0876") + buf.write("\u0877\7k\2\2\u0877\u0878\7f\2\2\u0878\u0879\7g\2\2\u0879") + buf.write("\u087a\7s\2\2\u087a\u087b\7k\2\2\u087b\u087c\7f\2\2\u087c") + buf.write("\u0194\3\2\2\2\u087d\u087e\7k\2\2\u087e\u087f\7f\2\2\u087f") + buf.write("\u0880\7g\2\2\u0880\u0881\7s\2\2\u0881\u0882\7x\2\2\u0882") + buf.write("\u0883\7c\2\2\u0883\u0884\7n\2\2\u0884\u0885\7n\2\2\u0885") + buf.write("\u0886\7k\2\2\u0886\u0887\7u\2\2\u0887\u0888\7v\2\2\u0888") + buf.write("\u0196\3\2\2\2\u0889\u088a\7s\2\2\u088a\u088b\7w\2\2\u088b") + buf.write("\u088c\7g\2\2\u088c\u088d\7u\2\2\u088d\u088e\7v\2\2\u088e") + buf.write("\u088f\7k\2\2\u088f\u0890\7q\2\2\u0890\u0891\7p\2\2\u0891") + buf.write("\u0892\7t\2\2\u0892\u0893\7g\2\2\u0893\u0894\7h\2\2\u0894") + buf.write("\u0198\3\2\2\2\u0895\u0896\7t\2\2\u0896\u0897\7w\2\2\u0897") + buf.write("\u0898\7n\2\2\u0898\u0899\7g\2\2\u0899\u089a\7t\2\2\u089a") + buf.write("\u089b\7g\2\2\u089b\u089c\7h\2\2\u089c\u019a\3\2\2\2\u089d") + buf.write("\u089e\7u\2\2\u089e\u089f\7v\2\2\u089f\u08a0\7t\2\2\u08a0") + buf.write("\u08a1\7k\2\2\u08a1\u08a2\7p\2\2\u08a2\u08a3\7i\2\2\u08a3") + buf.write("\u08a4\7t\2\2\u08a4\u08a5\7g\2\2\u08a5\u08a6\7h\2\2\u08a6") + buf.write("\u019c\3\2\2\2\u08a7\u08a8\7r\2\2\u08a8\u08a9\7w\2\2\u08a9") + buf.write("\u08aa\7u\2\2\u08aa\u08ab\7j\2\2\u08ab\u08ac\7v\2\2\u08ac") + buf.write("\u08ad\7j\2\2\u08ad\u08ae\7k\2\2\u08ae\u08af\7u\2\2\u08af") + buf.write("\u019e\3\2\2\2\u08b0\u08b1\7u\2\2\u08b1\u08b2\7g\2\2\u08b2") + buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b5") + buf.write("\u08b6\7k\2\2\u08b6\u08b7\7v\2\2\u08b7\u08b8\7{\2\2\u08b8") + buf.write("\u01a0\3\2\2\2\u08b9\u08ba\7i\2\2\u08ba\u08bb\7g\2\2\u08bb") + buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08be") + buf.write("\u08bf\7T\2\2\u08bf\u08c0\7W\2\2\u08c0\u08c1\7G\2\2\u08c1") + buf.write("\u01a4\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3\u08c4\7C\2\2\u08c4") + buf.write("\u08c5\7N\2\2\u08c5\u08c6\7U\2\2\u08c6\u08c7\7G\2\2\u08c7") + buf.write("\u01a6\3\2\2\2\u08c8\u08c9\7Q\2\2\u08c9\u08ca\7P\2\2\u08ca") + buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08cd") + buf.write("\u08ce\7P\2\2\u08ce\u08cf\7G\2\2\u08cf\u08d0\7U\2\2\u08d0") + buf.write("\u01aa\3\2\2\2\u08d1\u08d2\7\\\2\2\u08d2\u08d3\7G\2\2") + buf.write("\u08d3\u08d4\7T\2\2\u08d4\u08d5\7Q\2\2\u08d5\u01ac\3\2") + buf.write("\2\2\u08d6\u08d7\7W\2\2\u08d7\u08d8\7P\2\2\u08d8\u08d9") + buf.write("\7F\2\2\u08d9\u08da\7G\2\2\u08da\u08db\7H\2\2\u08db\u08dc") + buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08df") + buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e2") + buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e5") + buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b0") + buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08eb") + buf.write("\7p\2\2\u08eb\u08ec\7i\2\2\u08ec\u08ed\7v\2\2\u08ed\u08ee") + buf.write("\7j\2\2\u08ee\u01b2\3\2\2\2\u08ef\u08f0\7C\2\2\u08f0\u08f1") + buf.write("\7P\2\2\u08f1\u08f2\7F\2\2\u08f2\u01b4\3\2\2\2\u08f3\u08f4") + buf.write("\7Q\2\2\u08f4\u08f5\7T\2\2\u08f5\u01b6\3\2\2\2\u08f6\u08f7") + buf.write("\7P\2\2\u08f7\u08f8\7Q\2\2\u08f8\u08f9\7V\2\2\u08f9\u01b8") + buf.write("\3\2\2\2\u08fa\u08fb\7u\2\2\u08fb\u08fc\7g\2\2\u08fc\u08fd") + buf.write("\7v\2\2\u08fd\u01ba\3\2\2\2\u08fe\u08ff\7\u0080\2\2\u08ff") + buf.write("\u01bc\3\2\2\2\u0900\u0901\7d\2\2\u0901\u0902\7q\2\2\u0902") + buf.write("\u0903\7q\2\2\u0903\u0904\7n\2\2\u0904\u0905\7x\2\2\u0905") + buf.write("\u0906\7c\2\2\u0906\u0907\7n\2\2\u0907\u01be\3\2\2\2\u0908") + buf.write("\u0909\7u\2\2\u0909\u090a\7v\2\2\u090a\u090b\7t\2\2\u090b") + buf.write("\u090c\7k\2\2\u090c\u090d\7p\2\2\u090d\u090e\7i\2\2\u090e") + buf.write("\u090f\7x\2\2\u090f\u0910\7c\2\2\u0910\u0911\7n\2\2\u0911") + buf.write("\u01c0\3\2\2\2\u0912\u0913\7w\2\2\u0913\u0914\7p\2\2\u0914") + buf.write("\u0915\7k\2\2\u0915\u0916\7p\2\2\u0916\u0917\7v\2\2\u0917") + buf.write("\u0918\7x\2\2\u0918\u0919\7c\2\2\u0919\u091a\7n\2\2\u091a") + buf.write("\u01c2\3\2\2\2\u091b\u091c\7v\2\2\u091c\u091d\7q\2\2\u091d") + buf.write("\u091e\7w\2\2\u091e\u091f\7r\2\2\u091f\u0920\7r\2\2\u0920") + buf.write("\u0921\7g\2\2\u0921\u0922\7t\2\2\u0922\u01c4\3\2\2\2\u0923") + buf.write("\u0924\7v\2\2\u0924\u0925\7q\2\2\u0925\u0926\7n\2\2\u0926") + buf.write("\u0927\7q\2\2\u0927\u0928\7y\2\2\u0928\u0929\7g\2\2\u0929") + buf.write("\u092a\7t\2\2\u092a\u01c6\3\2\2\2\u092b\u092c\7o\2\2\u092c") + buf.write("\u092d\7c\2\2\u092d\u092e\7v\2\2\u092e\u092f\7e\2\2\u092f") + buf.write("\u0930\7j\2\2\u0930\u01c8\3\2\2\2\u0931\u0932\7o\2\2\u0932") + buf.write("\u0933\7c\2\2\u0933\u0934\7v\2\2\u0934\u0935\7e\2\2\u0935") + buf.write("\u0936\7j\2\2\u0936\u0937\7\64\2\2\u0937\u01ca\3\2\2\2") + buf.write("\u0938\u0939\7e\2\2\u0939\u093a\7c\2\2\u093a\u093b\7v") + buf.write("\2\2\u093b\u093c\7g\2\2\u093c\u093d\7p\2\2\u093d\u093e") + buf.write("\7c\2\2\u093e\u093f\7v\2\2\u093f\u0940\7g\2\2\u0940\u01cc") + buf.write("\3\2\2\2\u0941\u0942\7s\2\2\u0942\u0943\7w\2\2\u0943\u0944") + buf.write("\7g\2\2\u0944\u0945\7u\2\2\u0945\u0946\7v\2\2\u0946\u0947") + buf.write("\7k\2\2\u0947\u0948\7q\2\2\u0948\u0949\7p\2\2\u0949\u094a") + buf.write("\7t\2\2\u094a\u094b\7g\2\2\u094b\u094c\7h\2\2\u094c\u094d") + buf.write("\7x\2\2\u094d\u094e\7c\2\2\u094e\u094f\7n\2\2\u094f\u01ce") + buf.write("\3\2\2\2\u0950\u0951\7u\2\2\u0951\u0952\7v\2\2\u0952\u0953") + buf.write("\7t\2\2\u0953\u0954\7k\2\2\u0954\u0955\7p\2\2\u0955\u0956") + buf.write("\7i\2\2\u0956\u0957\7t\2\2\u0957\u0958\7g\2\2\u0958\u0959") + buf.write("\7h\2\2\u0959\u095a\7x\2\2\u095a\u095b\7c\2\2\u095b\u095c") + buf.write("\7n\2\2\u095c\u01d0\3\2\2\2\u095d\u095e\7o\2\2\u095e\u095f") + buf.write("\7c\2\2\u095f\u0960\7r\2\2\u0960\u01d2\3\2\2\2\u0961\u0962") + buf.write("\7t\2\2\u0962\u0963\7g\2\2\u0963\u0964\7h\2\2\u0964\u0965") + buf.write("\7t\2\2\u0965\u0966\7g\2\2\u0966\u0967\7u\2\2\u0967\u0968") + buf.write("\7j\2\2\u0968\u0969\7i\2\2\u0969\u096a\7w\2\2\u096a\u096b") + buf.write("\7k\2\2\u096b\u096c\7f\2\2\u096c\u01d4\3\2\2\2\u096d\u096e") + buf.write("\7U\2\2\u096e\u096f\7V\2\2\u096f\u0970\7T\2\2\u0970\u0971") + buf.write("\7K\2\2\u0971\u0972\7P\2\2\u0972\u0973\7I\2\2\u0973\u0974") + buf.write("\7a\2\2\u0974\u0975\7V\2\2\u0975\u0976\7Q\2\2\u0976\u0977") + buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d6") + buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097d") + buf.write("\7V\2\2\u097d\u097e\7K\2\2\u097e\u097f\7Q\2\2\u097f\u0980") + buf.write("\7P\2\2\u0980\u0981\7a\2\2\u0981\u0982\7F\2\2\u0982\u0983") + buf.write("\7G\2\2\u0983\u0984\7H\2\2\u0984\u0985\7C\2\2\u0985\u0986") + buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01d8") + buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u098c") + buf.write("\7V\2\2\u098c\u098d\7K\2\2\u098d\u098e\7Q\2\2\u098e\u098f") + buf.write("\7P\2\2\u098f\u0990\7a\2\2\u0990\u0991\7F\2\2\u0991\u0992") + buf.write("\7G\2\2\u0992\u0993\7H\2\2\u0993\u0994\7C\2\2\u0994\u0995") + buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u0998") + buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099b") + buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099e") + buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a1") + buf.write("\7T\2\2\u09a1\u09a2\7K\2\2\u09a2\u09a3\7E\2\2\u09a3\u09a4") + buf.write("\7a\2\2\u09a4\u09a5\7U\2\2\u09a5\u09a6\7K\2\2\u09a6\u09a7") + buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09aa") + buf.write("\7\63\2\2\u09aa\u01dc\3\2\2\2\u09ab\u09ac\7P\2\2\u09ac") + buf.write("\u09ad\7W\2\2\u09ad\u09ae\7O\2\2\u09ae\u09af\7G\2\2\u09af") + buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b2") + buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b5") + buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09b8") + buf.write("\u09b9\7\64\2\2\u09b9\u01de\3\2\2\2\u09ba\u09bb\7P\2\2") + buf.write("\u09bb\u09bc\7W\2\2\u09bc\u09bd\7O\2\2\u09bd\u09be\7G") + buf.write("\2\2\u09be\u09bf\7T\2\2\u09bf\u09c0\7K\2\2\u09c0\u09c1") + buf.write("\7E\2\2\u09c1\u09c2\7a\2\2\u09c2\u09c3\7U\2\2\u09c3\u09c4") + buf.write("\7K\2\2\u09c4\u09c5\7\\\2\2\u09c5\u09c6\7G\2\2\u09c6\u09c7") + buf.write("\7a\2\2\u09c7\u09c8\7\66\2\2\u09c8\u01e0\3\2\2\2\u09c9") + buf.write("\u09ca\7P\2\2\u09ca\u09cb\7W\2\2\u09cb\u09cc\7O\2\2\u09cc") + buf.write("\u09cd\7G\2\2\u09cd\u09ce\7T\2\2\u09ce\u09cf\7K\2\2\u09cf") + buf.write("\u09d0\7E\2\2\u09d0\u09d1\7a\2\2\u09d1\u09d2\7U\2\2\u09d2") + buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09d5") + buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d8") + buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09db") + buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09de") + buf.write("\u09df\7[\2\2\u09df\u09e0\7a\2\2\u09e0\u09e1\7K\2\2\u09e1") + buf.write("\u09e2\7P\2\2\u09e2\u09e3\7V\2\2\u09e3\u09e4\7a\2\2\u09e4") + buf.write("\u09e5\7F\2\2\u09e5\u09e6\7G\2\2\u09e6\u09e7\7E\2\2\u09e7") + buf.write("\u01e4\3\2\2\2\u09e8\u09e9\7F\2\2\u09e9\u09ea\7K\2\2\u09ea") + buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09ed") + buf.write("\u09ee\7C\2\2\u09ee\u09ef\7[\2\2\u09ef\u09f0\7a\2\2\u09f0") + buf.write("\u09f1\7W\2\2\u09f1\u09f2\7K\2\2\u09f2\u09f3\7P\2\2\u09f3") + buf.write("\u09f4\7V\2\2\u09f4\u09f5\7a\2\2\u09f5\u09f6\7F\2\2\u09f6") + buf.write("\u09f7\7G\2\2\u09f7\u09f8\7E\2\2\u09f8\u01e6\3\2\2\2\u09f9") + buf.write("\u09fa\7F\2\2\u09fa\u09fb\7K\2\2\u09fb\u09fc\7U\2\2\u09fc") + buf.write("\u09fd\7R\2\2\u09fd\u09fe\7N\2\2\u09fe\u09ff\7C\2\2\u09ff") + buf.write("\u0a00\7[\2\2\u0a00\u0a01\7a\2\2\u0a01\u0a02\7W\2\2\u0a02") + buf.write("\u0a03\7K\2\2\u0a03\u0a04\7P\2\2\u0a04\u0a05\7V\2\2\u0a05") + buf.write("\u0a06\7a\2\2\u0a06\u0a07\7J\2\2\u0a07\u0a08\7G\2\2\u0a08") + buf.write("\u0a09\7Z\2\2\u0a09\u01e8\3\2\2\2\u0a0a\u0a0b\7K\2\2\u0a0b") + buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0e") + buf.write("\u0a0f\7P\2\2\u0a0f\u0a10\7U\2\2\u0a10\u0a11\7K\2\2\u0a11") + buf.write("\u0a12\7V\2\2\u0a12\u0a13\7K\2\2\u0a13\u0a14\7X\2\2\u0a14") + buf.write("\u0a15\7G\2\2\u0a15\u01ea\3\2\2\2\u0a16\u0a17\7U\2\2\u0a17") + buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1a") + buf.write("\u0a1b\7K\2\2\u0a1b\u0a1c\7V\2\2\u0a1c\u0a1d\7K\2\2\u0a1d") + buf.write("\u0a1e\7X\2\2\u0a1e\u0a1f\7G\2\2\u0a1f\u01ec\3\2\2\2\u0a20") + buf.write("\u0a21\7N\2\2\u0a21\u0a22\7C\2\2\u0a22\u0a23\7U\2\2\u0a23") + buf.write("\u0a24\7V\2\2\u0a24\u0a25\7a\2\2\u0a25\u0a26\7P\2\2\u0a26") + buf.write("\u0a27\7Q\2\2\u0a27\u0a28\7P\2\2\u0a28\u0a29\7a\2\2\u0a29") + buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2c") + buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2f") + buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a32") + buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a35") + buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a38") + buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3b") + buf.write("\u0a3c\7V\2\2\u0a3c\u0a3d\7E\2\2\u0a3d\u0a3e\7J\2\2\u0a3e") + buf.write("\u01f0\3\2\2\2\u0a3f\u0a40\7\62\2\2\u0a40\u0a41\7z\2\2") + buf.write("\u0a41\u0a43\3\2\2\2\u0a42\u0a44\t\2\2\2\u0a43\u0a42\3") + buf.write("\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46") + buf.write("\3\2\2\2\u0a46\u0a4d\3\2\2\2\u0a47\u0a49\t\3\2\2\u0a48") + buf.write("\u0a47\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a48\3\2\2\2") + buf.write("\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4d\3\2\2\2\u0a4c\u0a3f\3") + buf.write("\2\2\2\u0a4c\u0a48\3\2\2\2\u0a4d\u01f2\3\2\2\2\u0a4e\u0a52") + buf.write("\t\4\2\2\u0a4f\u0a51\t\5\2\2\u0a50\u0a4f\3\2\2\2\u0a51") + buf.write("\u0a54\3\2\2\2\u0a52\u0a50\3\2\2\2\u0a52\u0a53\3\2\2\2") + buf.write("\u0a53\u01f4\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a55\u0a57\7") + buf.write("%\2\2\u0a56\u0a58\5\u01fb\u00fe\2\u0a57\u0a56\3\2\2\2") + buf.write("\u0a57\u0a58\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\7") + buf.write("f\2\2\u0a5a\u0a5b\7g\2\2\u0a5b\u0a5c\7h\2\2\u0a5c\u0a5d") + buf.write("\7k\2\2\u0a5d\u0a5e\7p\2\2\u0a5e\u0a5f\7g\2\2\u0a5f\u0a63") + buf.write("\3\2\2\2\u0a60\u0a62\n\6\2\2\u0a61\u0a60\3\2\2\2\u0a62") + buf.write("\u0a65\3\2\2\2\u0a63\u0a61\3\2\2\2\u0a63\u0a64\3\2\2\2") + buf.write("\u0a64\u0a66\3\2\2\2\u0a65\u0a63\3\2\2\2\u0a66\u0a67\b") + buf.write("\u00fb\2\2\u0a67\u01f6\3\2\2\2\u0a68\u0a6a\7%\2\2\u0a69") + buf.write("\u0a6b\5\u01fb\u00fe\2\u0a6a\u0a69\3\2\2\2\u0a6a\u0a6b") + buf.write("\3\2\2\2\u0a6b\u0a6c\3\2\2\2\u0a6c\u0a6d\7n\2\2\u0a6d") + buf.write("\u0a6e\7k\2\2\u0a6e\u0a6f\7p\2\2\u0a6f\u0a70\7g\2\2\u0a70") + buf.write("\u0a74\3\2\2\2\u0a71\u0a73\n\6\2\2\u0a72\u0a71\3\2\2\2") + buf.write("\u0a73\u0a76\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75\3") + buf.write("\2\2\2\u0a75\u0a77\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a77\u0a78") + buf.write("\b\u00fc\2\2\u0a78\u01f8\3\2\2\2\u0a79\u0a7b\7%\2\2\u0a7a") + buf.write("\u0a7c\5\u01fb\u00fe\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c") + buf.write("\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7e\7k\2\2\u0a7e") + buf.write("\u0a7f\7p\2\2\u0a7f\u0a80\7e\2\2\u0a80\u0a81\7n\2\2\u0a81") + buf.write("\u0a82\7w\2\2\u0a82\u0a83\7f\2\2\u0a83\u0a84\7g\2\2\u0a84") + buf.write("\u0a88\3\2\2\2\u0a85\u0a87\n\6\2\2\u0a86\u0a85\3\2\2\2") + buf.write("\u0a87\u0a8a\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a88\u0a89\3") + buf.write("\2\2\2\u0a89\u0a8b\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8c") + buf.write("\b\u00fd\2\2\u0a8c\u01fa\3\2\2\2\u0a8d\u0a8f\t\7\2\2\u0a8e") + buf.write("\u0a8d\3\2\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a8e\3\2\2\2") + buf.write("\u0a90\u0a91\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a93\b") + buf.write("\u00fe\2\2\u0a93\u01fc\3\2\2\2\u0a94\u0a96\7\17\2\2\u0a95") + buf.write("\u0a97\7\f\2\2\u0a96\u0a95\3\2\2\2\u0a96\u0a97\3\2\2\2") + buf.write("\u0a97\u0a9a\3\2\2\2\u0a98\u0a9a\7\f\2\2\u0a99\u0a94\3") + buf.write("\2\2\2\u0a99\u0a98\3\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a9c") + buf.write("\b\u00ff\2\2\u0a9c\u01fe\3\2\2\2\u0a9d\u0a9e\7\61\2\2") + buf.write("\u0a9e\u0a9f\7\61\2\2\u0a9f\u0aa3\3\2\2\2\u0aa0\u0aa2") + buf.write("\n\b\2\2\u0aa1\u0aa0\3\2\2\2\u0aa2\u0aa5\3\2\2\2\u0aa3") + buf.write("\u0aa1\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa6\3\2\2\2") + buf.write("\u0aa5\u0aa3\3\2\2\2\u0aa6\u0aa7\b\u0100\2\2\u0aa7\u0200") + buf.write("\3\2\2\2\u0aa8\u0aa9\7g\2\2\u0aa9\u0aaa\7z\2\2\u0aaa\u0aab") + buf.write("\7v\2\2\u0aab\u0aac\7g\2\2\u0aac\u0aad\7t\2\2\u0aad\u0aae") + buf.write("\7p\2\2\u0aae\u0ab2\3\2\2\2\u0aaf\u0ab1\n\6\2\2\u0ab0") + buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab4\3\2\2\2\u0ab2\u0ab0\3\2\2\2") + buf.write("\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab2\3") + buf.write("\2\2\2\u0ab5\u0ab6\b\u0101\2\2\u0ab6\u0202\3\2\2\2\22") + buf.write("\2\u0a45\u0a4a\u0a4c\u0a52\u0a57\u0a63\u0a6a\u0a74\u0a7b") + buf.write("\u0a88\u0a90\u0a96\u0a99\u0aa3\u0ab2\3\b\2\2") + return buf.getvalue() + + +class VfrSyntaxLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + T__0 = 1 + T__1 = 2 + T__2 = 3 + T__3 = 4 + T__4 = 5 + T__5 = 6 + T__6 = 7 + T__7 = 8 + T__8 = 9 + T__9 = 10 + T__10 = 11 + T__11 = 12 + T__12 = 13 + T__13 = 14 + T__14 = 15 + T__15 = 16 + Define = 17 + Include = 18 + FormPkgType = 19 + OpenBrace = 20 + CloseBrace = 21 + OpenParen = 22 + CloseParen = 23 + OpenBracket = 24 + CloseBracket = 25 + Dot = 26 + Negative = 27 + Colon = 28 + Slash = 29 + Semicolon = 30 + Comma = 31 + Equal = 32 + NotEqual = 33 + LessEqual = 34 + Less = 35 + GreaterEqual = 36 + Greater = 37 + BitWiseOr = 38 + BitWiseAnd = 39 + DevicePath = 40 + FormSet = 41 + FormSetId = 42 + EndFormSet = 43 + Title = 44 + FormId = 45 + OneOf = 46 + EndOneOf = 47 + Prompt = 48 + OrderedList = 49 + MaxContainers = 50 + EndList = 51 + EndForm = 52 + Form = 53 + FormMap = 54 + MapTitle = 55 + MapGuid = 56 + Subtitle = 57 + EndSubtitle = 58 + Help = 59 + Text = 60 + Option = 61 + FLAGS = 62 + Date = 63 + EndDate = 64 + Year = 65 + Month = 66 + Day = 67 + Time = 68 + EndTime = 69 + Hour = 70 + Minute = 71 + Second = 72 + GrayOutIf = 73 + Label = 74 + Timeout = 75 + Inventory = 76 + NonNvDataMap = 77 + Struct = 78 + Union = 79 + Boolean = 80 + Uint64 = 81 + Uint32 = 82 + Uint16 = 83 + Uint8 = 84 + EFI_STRING_ID = 85 + EFI_HII_DATE = 86 + EFI_HII_TIME = 87 + EFI_HII_REF = 88 + Uuid = 89 + CheckBox = 90 + EndCheckBox = 91 + Numeric = 92 + EndNumeric = 93 + Minimum = 94 + Maximum = 95 + Step = 96 + Default = 97 + Password = 98 + EndPassword = 99 + String = 100 + EndString = 101 + MinSize = 102 + MaxSize = 103 + Encoding = 104 + SuppressIf = 105 + DisableIf = 106 + Hidden = 107 + Goto = 108 + FormSetGuid = 109 + InconsistentIf = 110 + WarningIf = 111 + NoSubmitIf = 112 + EndIf = 113 + Key = 114 + DefaultFlag = 115 + ManufacturingFlag = 116 + CheckBoxDefaultFlag = 117 + CheckBoxDefaultMfgFlag = 118 + InteractiveFlag = 119 + NVAccessFlag = 120 + ResetRequiredFlag = 121 + ReconnectRequiredFlag = 122 + LateCheckFlag = 123 + ReadOnlyFlag = 124 + OptionOnlyFlag = 125 + RestStyleFlag = 126 + Class = 127 + Subclass = 128 + ClassGuid = 129 + TypeDef = 130 + Restore = 131 + Save = 132 + Defaults = 133 + Banner = 134 + Align = 135 + Left = 136 + Right = 137 + Center = 138 + Line = 139 + Name = 140 + VarId = 141 + Question = 142 + QuestionId = 143 + Image = 144 + Locked = 145 + Rule = 146 + EndRule = 147 + Value = 148 + Read = 149 + Write = 150 + ResetButton = 151 + EndResetButton = 152 + DefaultStore = 153 + Attribute = 154 + Varstore = 155 + Efivarstore = 156 + VarSize = 157 + NameValueVarStore = 158 + Action = 159 + Config = 160 + EndAction = 161 + Refresh = 162 + Interval = 163 + VarstoreDevice = 164 + GuidOp = 165 + EndGuidOp = 166 + DataType = 167 + Data = 168 + Modal = 169 + ClassNonDevice = 170 + ClassDiskDevice = 171 + ClassVideoDevice = 172 + ClassNetworkDevice = 173 + ClassInputDevice = 174 + ClassOnBoardDevice = 175 + ClassOtherDevice = 176 + SubclassSetupApplication = 177 + SubclassGeneralApplication = 178 + SubclassFrontPage = 179 + SubclassSingleUse = 180 + YearSupppressFlag = 181 + MonthSuppressFlag = 182 + DaySuppressFlag = 183 + HourSupppressFlag = 184 + MinuteSuppressFlag = 185 + SecondSuppressFlag = 186 + StorageNormalFlag = 187 + StorageTimeFlag = 188 + StorageWakeUpFlag = 189 + UniQueFlag = 190 + NoEmptyFlag = 191 + Cond = 192 + Find = 193 + Mid = 194 + Tok = 195 + Span = 196 + Dup = 197 + VarEqVal = 198 + Var = 199 + IdEqVal = 200 + IdEqId = 201 + IdEqValList = 202 + QuestionRef = 203 + RuleRef = 204 + StringRef = 205 + PushThis = 206 + Security = 207 + Get = 208 + TrueSymbol = 209 + FalseSymbol = 210 + One = 211 + Ones = 212 + Zero = 213 + Undefined = 214 + Version = 215 + Length = 216 + AND = 217 + OR = 218 + NOT = 219 + Set = 220 + BitWiseNot = 221 + BoolVal = 222 + StringVal = 223 + UnIntVal = 224 + ToUpper = 225 + ToLower = 226 + Match = 227 + Match2 = 228 + Catenate = 229 + QuestionRefVal = 230 + StringRefVal = 231 + Map = 232 + RefreshGuid = 233 + StringToken = 234 + OptionDefault = 235 + OptionDefaultMfg = 236 + NumericSizeOne = 237 + NumericSizeTwo = 238 + NumericSizeFour = 239 + NumericSizeEight = 240 + DisPlayIntDec = 241 + DisPlayUIntDec = 242 + DisPlayUIntHex = 243 + Insensitive = 244 + Sensitive = 245 + LastNonMatch = 246 + FirstNonMatch = 247 + Number = 248 + StringIdentifier = 249 + ComplexDefine = 250 + LineDefinition = 251 + IncludeDefinition = 252 + Whitespace = 253 + Newline = 254 + LineComment = 255 + Extern = 256 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "<INVALID>", + "'show'", "'push'", "'pop'", "'#pragma'", "'pack'", "'='", "'IMAGE_TOKEN'", + "'HORIZONTAL'", "'MULTI_LINE'", "'<<'", "'>>'", "'+'", "'*'", + "'%'", "'format'", "'?'", "'#define'", "'#include'", "'formpkgtype'", + "'{'", "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'", + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", "'>='", + "'>'", "'|'", "'&'", "'devicepath'", "'formset'", "'formsetid'", + "'endformset'", "'title'", "'formid'", "'oneof'", "'endoneof'", + "'prompt'", "'orderedlist'", "'maxcontainers'", "'endlist'", + "'endform'", "'form'", "'formmap'", "'maptitle'", "'mapguid'", + "'subtitle'", "'endsubtitle'", "'help'", "'text'", "'option'", + "'flags'", "'date'", "'enddate'", "'year'", "'month'", "'day'", + "'time'", "'endtime'", "'hour'", "'minute'", "'second'", "'grayoutif'", + "'label'", "'timeout'", "'inventory'", "'_NON_NV_DATA_MAP'", + "'struct'", "'union'", "'BOOLEAN'", "'UINT64'", "'UINT32'", + "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", "'EFI_HII_DATE'", + "'EFI_HII_TIME'", "'EFI_HII_REF'", "'guid'", "'checkbox'", "'endcheckbox'", + "'numeric'", "'endnumeric'", "'minimum'", "'maximum'", "'step'", + "'default'", "'password'", "'endpassword'", "'string'", "'endstring'", + "'minsize'", "'maxsize'", "'encoding'", "'suppressif'", "'disableif'", + "'hidden'", "'goto'", "'formsetguid'", "'inconsistentif'", "'warningif'", + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'", + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'", + "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'", "'LATE_CHECK'", + "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", "'class'", + "'subclass'", "'classguid'", "'typedef'", "'restore'", "'save'", + "'defaults'", "'banner'", "'align'", "'left'", "'right'", "'center'", + "'line'", "'name'", "'varid'", "'question'", "'questionid'", + "'image'", "'locked'", "'rule'", "'endrule'", "'value'", "'read'", + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'", + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'", "'namevaluevarstore'", + "'action'", "'config'", "'endaction'", "'refresh'", "'interval'", + "'varstoredevice'", "'guidop'", "'endguidop'", "'datatype'", + "'data'", "'modal'", "'NON_DEVICE'", "'DISK_DEVICE'", "'VIDEO_DEVICE'", + "'NETWORK_DEVICE'", "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'", + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'", + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'", "'DAY_SUPPRESS'", + "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", "'SECOND_SUPPRESS'", + "'STORAGE_NORMAL'", "'STORAGE_TIME'", "'STORAGE_WAKEUP'", "'UNIQUE'", + "'NOEMPTY'", "'cond'", "'find'", "'mid'", "'token'", "'span'", + "'dup'", "'vareqval'", "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'", + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", "'security'", + "'get'", "'TRUE'", "'FALSE'", "'ONE'", "'ONES'", "'ZERO'", "'UNDEFINED'", + "'VERSION'", "'length'", "'AND'", "'OR'", "'NOT'", "'set'", + "'~'", "'boolval'", "'stringval'", "'unintval'", "'toupper'", + "'tolower'", "'match'", "'match2'", "'catenate'", "'questionrefval'", + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'", + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'", + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'", + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'", + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'", "'FIRST_NON_MATCH'" ] + + symbolicNames = [ "<INVALID>", + "Define", "Include", "FormPkgType", "OpenBrace", "CloseBrace", + "OpenParen", "CloseParen", "OpenBracket", "CloseBracket", "Dot", + "Negative", "Colon", "Slash", "Semicolon", "Comma", "Equal", + "NotEqual", "LessEqual", "Less", "GreaterEqual", "Greater", + "BitWiseOr", "BitWiseAnd", "DevicePath", "FormSet", "FormSetId", + "EndFormSet", "Title", "FormId", "OneOf", "EndOneOf", "Prompt", + "OrderedList", "MaxContainers", "EndList", "EndForm", "Form", + "FormMap", "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", + "Help", "Text", "Option", "FLAGS", "Date", "EndDate", "Year", + "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second", + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap", + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16", + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME", "EFI_HII_REF", + "Uuid", "CheckBox", "EndCheckBox", "Numeric", "EndNumeric", + "Minimum", "Maximum", "Step", "Default", "Password", "EndPassword", + "String", "EndString", "MinSize", "MaxSize", "Encoding", "SuppressIf", + "DisableIf", "Hidden", "Goto", "FormSetGuid", "InconsistentIf", + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag", + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag", + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag", + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag", + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", "Save", + "Defaults", "Banner", "Align", "Left", "Right", "Center", "Line", + "Name", "VarId", "Question", "QuestionId", "Image", "Locked", + "Rule", "EndRule", "Value", "Read", "Write", "ResetButton", + "EndResetButton", "DefaultStore", "Attribute", "Varstore", "Efivarstore", + "VarSize", "NameValueVarStore", "Action", "Config", "EndAction", + "Refresh", "Interval", "VarstoreDevice", "GuidOp", "EndGuidOp", + "DataType", "Data", "Modal", "ClassNonDevice", "ClassDiskDevice", + "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice", + "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication", + "SubclassGeneralApplication", "SubclassFrontPage", "SubclassSingleUse", + "YearSupppressFlag", "MonthSuppressFlag", "DaySuppressFlag", + "HourSupppressFlag", "MinuteSuppressFlag", "SecondSuppressFlag", + "StorageNormalFlag", "StorageTimeFlag", "StorageWakeUpFlag", + "UniQueFlag", "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", + "Dup", "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList", + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security", + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero", "Undefined", + "Version", "Length", "AND", "OR", "NOT", "Set", "BitWiseNot", + "BoolVal", "StringVal", "UnIntVal", "ToUpper", "ToLower", "Match", + "Match2", "Catenate", "QuestionRefVal", "StringRefVal", "Map", + "RefreshGuid", "StringToken", "OptionDefault", "OptionDefaultMfg", + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour", "NumericSizeEight", + "DisPlayIntDec", "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", + "Sensitive", "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier", + "ComplexDefine", "LineDefinition", "IncludeDefinition", "Whitespace", + "Newline", "LineComment", "Extern" ] + + ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", + "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", + "T__14", "T__15", "Define", "Include", "FormPkgType", + "OpenBrace", "CloseBrace", "OpenParen", "CloseParen", + "OpenBracket", "CloseBracket", "Dot", "Negative", "Colon", + "Slash", "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual", + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd", + "DevicePath", "FormSet", "FormSetId", "EndFormSet", "Title", + "FormId", "OneOf", "EndOneOf", "Prompt", "OrderedList", + "MaxContainers", "EndList", "EndForm", "Form", "FormMap", + "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", "Help", + "Text", "Option", "FLAGS", "Date", "EndDate", "Year", + "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second", + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap", + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16", + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME", + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", "Numeric", + "EndNumeric", "Minimum", "Maximum", "Step", "Default", + "Password", "EndPassword", "String", "EndString", "MinSize", + "MaxSize", "Encoding", "SuppressIf", "DisableIf", "Hidden", + "Goto", "FormSetGuid", "InconsistentIf", "WarningIf", + "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag", + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag", + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag", + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag", + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", + "Save", "Defaults", "Banner", "Align", "Left", "Right", + "Center", "Line", "Name", "VarId", "Question", "QuestionId", + "Image", "Locked", "Rule", "EndRule", "Value", "Read", + "Write", "ResetButton", "EndResetButton", "DefaultStore", + "Attribute", "Varstore", "Efivarstore", "VarSize", "NameValueVarStore", + "Action", "Config", "EndAction", "Refresh", "Interval", + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", "Data", + "Modal", "ClassNonDevice", "ClassDiskDevice", "ClassVideoDevice", + "ClassNetworkDevice", "ClassInputDevice", "ClassOnBoardDevice", + "ClassOtherDevice", "SubclassSetupApplication", "SubclassGeneralApplication", + "SubclassFrontPage", "SubclassSingleUse", "YearSupppressFlag", + "MonthSuppressFlag", "DaySuppressFlag", "HourSupppressFlag", + "MinuteSuppressFlag", "SecondSuppressFlag", "StorageNormalFlag", + "StorageTimeFlag", "StorageWakeUpFlag", "UniQueFlag", + "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", "Dup", + "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList", + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security", + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero", + "Undefined", "Version", "Length", "AND", "OR", "NOT", + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal", + "ToUpper", "ToLower", "Match", "Match2", "Catenate", "QuestionRefVal", + "StringRefVal", "Map", "RefreshGuid", "StringToken", "OptionDefault", + "OptionDefaultMfg", "NumericSizeOne", "NumericSizeTwo", + "NumericSizeFour", "NumericSizeEight", "DisPlayIntDec", + "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", "Sensitive", + "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier", + "ComplexDefine", "LineDefinition", "IncludeDefinition", + "Whitespace", "Newline", "LineComment", "Extern" ] + + grammarFileName = "VfrSyntax.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py new file mode 100644 index 0000000000..b6af21b795 --- /dev/null +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py @@ -0,0 +1,20460 @@ +# Generated from VfrSyntax.g4 by ANTLR 4.7.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +from typing import TextIO +import sys + + + +from VfrCompiler.CommonCtypes import * +from VfrCompiler.VfrFormPkg import * +from VfrCompiler.VfrUtility import * +from VfrCompiler.VfrTree import * + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0102") + buf.write("\u0ba3\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") + buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") + buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") + buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") + buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") + buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") + buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") + buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") + buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") + buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t") + buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t") + buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4") + buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4") + buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4") + buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4") + buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080") + buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084") + buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087") + buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b") + buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e") + buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092") + buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095") + buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099") + buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c") + buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0") + buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3") + buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7") + buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa") + buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae") + buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1") + buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5") + buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8") + buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc") + buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf") + buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3") + buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6") + buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca") + buf.write("\t\u00ca\4\u00cb\t\u00cb\3\2\3\2\3\2\7\2\u019a\n\2\f\2") + buf.write("\16\2\u019d\13\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\5\4\u01a6") + buf.write("\n\4\3\4\3\4\5\4\u01aa\n\4\3\5\5\5\u01ad\n\5\3\6\3\6\3") + buf.write("\6\3\6\3\6\3\6\5\6\u01b5\n\6\3\6\3\6\3\7\5\7\u01ba\n\7") + buf.write("\3\7\3\7\5\7\u01be\n\7\3\7\5\7\u01c1\n\7\3\7\3\7\3\7\3") + buf.write("\7\5\7\u01c7\n\7\3\7\3\7\3\b\5\b\u01cc\n\b\3\b\3\b\5\b") + buf.write("\u01d0\n\b\3\b\5\b\u01d3\n\b\3\b\3\b\3\b\3\b\5\b\u01d9") + buf.write("\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3") + buf.write("\t\3\t\3\t\3\t\7\t\u01eb\n\t\f\t\16\t\u01ee\13\t\3\n\3") + buf.write("\n\3\n\3\n\3\n\5\n\u01f5\n\n\3\n\3\n\3\13\3\13\3\13\3") + buf.write("\13\3\13\5\13\u01fe\n\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f") + buf.write("\5\f\u0207\n\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\5\r\u0210\n") + buf.write("\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\5\16\u0219\n\16\3") + buf.write("\16\3\16\3\17\3\17\3\17\3\17\3\17\5\17\u0222\n\17\3\17") + buf.write("\3\17\3\20\3\20\3\20\3\20\3\20\5\20\u022b\n\20\3\20\3") + buf.write("\20\3\21\3\21\3\21\3\21\3\21\5\21\u0234\n\21\3\21\3\21") + buf.write("\3\22\3\22\3\22\3\22\3\22\5\22\u023d\n\22\3\22\3\22\3") + buf.write("\23\3\23\3\23\3\23\3\23\5\23\u0246\n\23\3\23\3\23\3\24") + buf.write("\3\24\5\24\u024c\n\24\3\24\3\24\3\24\3\24\3\25\3\25\5") + buf.write("\25\u0254\n\25\3\25\3\25\3\25\3\25\3\26\3\26\5\26\u025c") + buf.write("\n\26\3\26\3\26\3\26\3\26\3\27\3\27\5\27\u0264\n\27\3") + buf.write("\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30") + buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30") + buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0282\n\30\3\30\3") + buf.write("\30\3\30\3\30\3\30\5\30\u0289\n\30\3\30\3\30\3\30\3\30") + buf.write("\3\30\5\30\u0290\n\30\3\30\3\30\3\30\3\30\3\31\3\31\3") + buf.write("\31\5\31\u0299\n\31\3\31\3\31\5\31\u029d\n\31\3\31\3\31") + buf.write("\5\31\u02a1\n\31\3\32\3\32\3\32\7\32\u02a6\n\32\f\32\16") + buf.write("\32\u02a9\13\32\3\33\3\33\3\34\3\34\3\35\7\35\u02b0\n") + buf.write("\35\f\35\16\35\u02b3\13\35\3\36\3\36\3\36\3\36\3\36\3") + buf.write("\36\3\36\3\36\3\36\3\36\5\36\u02bf\n\36\3\37\3\37\3\37") + buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37") + buf.write("\u02ce\n\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3") + buf.write(" \3 \3 \3 \3 \3 \3 \5 \u02e3\n \3 \3 \3 \3 \5 \u02e9\n") + buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3!\3") + buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0305\n!\3!\3!\3!\3!\5!\u030b") + buf.write("\n!\3!\3!\3!\3!\3!\7!\u0312\n!\f!\16!\u0315\13!\3!\3!") + buf.write("\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0327\n") + buf.write("!\3!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\5#\u0337") + buf.write("\n#\3#\3#\3#\3#\3#\3#\3#\6#\u0340\n#\r#\16#\u0341\3#\3") + buf.write("#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3") + buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3\'\3\'") + buf.write("\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0373\n\'") + buf.write("\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3)\3*\3*\3*\3*\5*\u0383") + buf.write("\n*\3*\3*\3*\3*\3*\5*\u038a\n*\3*\3*\3*\3*\5*\u0390\n") + buf.write("*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3") + buf.write(",\3,\3,\3,\3,\5,\u03a8\n,\3-\3-\3-\3-\3-\3-\3-\7-\u03b1") + buf.write("\n-\f-\16-\u03b4\13-\5-\u03b6\n-\3.\5.\u03b9\n.\3.\3.") + buf.write("\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3") + buf.write(".\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\7.\u03de") + buf.write("\n.\f.\16.\u03e1\13.\3.\5.\u03e4\n.\3/\3/\3/\3/\3/\3/") + buf.write("\3/\3\60\3\60\3\61\3\61\5\61\u03f1\n\61\3\62\3\62\3\62") + buf.write("\7\62\u03f6\n\62\f\62\16\62\u03f9\13\62\3\63\3\63\3\63") + buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\7\63") + buf.write("\u0408\n\63\f\63\16\63\u040b\13\63\3\63\3\63\3\63\3\64") + buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64") + buf.write("\3\64\3\64\3\64\5\64\u041f\n\64\3\65\3\65\3\65\3\65\3") + buf.write("\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65") + buf.write("\3\65\3\65\7\65\u0432\n\65\f\65\16\65\u0435\13\65\3\65") + buf.write("\7\65\u0438\n\65\f\65\16\65\u043b\13\65\3\65\3\65\3\65") + buf.write("\3\66\3\66\3\66\3\67\3\67\3\67\38\38\38\38\38\38\38\3") + buf.write("9\39\39\59\u0450\n9\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\5") + buf.write(":\u045d\n:\3:\3:\5:\u0461\n:\3:\3:\3:\5:\u0466\n:\3:\3") + buf.write(":\7:\u046a\n:\f:\16:\u046d\13:\5:\u046f\n:\3:\3:\5:\u0473") + buf.write("\n:\3;\3;\5;\u0477\n;\3<\3<\3<\7<\u047c\n<\f<\16<\u047f") + buf.write("\13<\3=\3=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3") + buf.write(">\3>\3>\3>\3>\3>\3>\5>\u0498\n>\3>\3>\3>\3>\3>\3>\7>\u04a0") + buf.write("\n>\f>\16>\u04a3\13>\3>\3>\3>\3>\3>\5>\u04aa\n>\3>\3>") + buf.write("\5>\u04ae\n>\3>\3>\3?\3?\5?\u04b4\n?\3@\3@\5@\u04b8\n") + buf.write("@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3") + buf.write("A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3") + buf.write("A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u04e6\nA\3A\3A\5A\u04ea\n") + buf.write("A\3A\3A\3A\3A\3A\5A\u04f1\nA\3A\3A\3A\3A\5A\u04f7\nA\3") + buf.write("A\3A\5A\u04fb\nA\3A\3A\3B\3B\3B\7B\u0502\nB\fB\16B\u0505") + buf.write("\13B\3C\3C\5C\u0509\nC\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\5") + buf.write("D\u0515\nD\3D\3D\3D\3E\3E\3E\3E\3E\3E\5E\u0520\nE\3F\3") + buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u052d\nF\3G\3G\3G\3G\3") + buf.write("G\3G\3G\3G\3G\3G\3G\3G\3G\7G\u053c\nG\fG\16G\u053f\13") + buf.write("G\3G\3G\5G\u0543\nG\3G\3G\3G\5G\u0548\nG\3H\3H\3H\3H\3") + buf.write("H\3H\3H\3H\3H\3H\3H\3H\3H\7H\u0557\nH\fH\16H\u055a\13") + buf.write("H\3H\3H\5H\u055e\nH\3H\3H\3H\5H\u0563\nH\3I\3I\3I\3I\3") + buf.write("I\3I\5I\u056b\nI\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3") + buf.write("K\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5") + buf.write("M\u058b\nM\3M\3M\3M\5M\u0590\nM\3N\7N\u0593\nN\fN\16N") + buf.write("\u0596\13N\3O\3O\3O\3O\3O\3O\3O\5O\u059f\nO\3P\3P\3P\3") + buf.write("P\3P\3P\3P\3P\5P\u05a9\nP\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u05b3") + buf.write("\nQ\fQ\16Q\u05b6\13Q\3Q\3Q\5Q\u05ba\nQ\3Q\3Q\3Q\5Q\u05bf") + buf.write("\nQ\3R\3R\3R\3R\3R\3R\3R\3R\7R\u05c9\nR\fR\16R\u05cc\13") + buf.write("R\3R\3R\5R\u05d0\nR\3R\3R\3R\5R\u05d5\nR\3S\3S\3S\3S\3") + buf.write("S\3S\3S\3S\5S\u05df\nS\3S\3S\3S\3S\5S\u05e5\nS\3T\3T\3") + buf.write("T\3T\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3") + buf.write("V\3V\3V\3V\3V\5V\u0600\nV\3V\3V\7V\u0604\nV\fV\16V\u0607") + buf.write("\13V\3V\3V\3W\3W\3W\7W\u060e\nW\fW\16W\u0611\13W\3X\3") + buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u061e\nX\3Y\3Y\3Y\3Y\3") + buf.write("Z\3Z\3Z\3Z\3[\7[\u0629\n[\f[\16[\u062c\13[\3\\\3\\\5\\") + buf.write("\u0630\n\\\3]\3]\5]\u0634\n]\3^\3^\3^\3^\3^\3^\3^\3^\3") + buf.write("^\5^\u063f\n^\3^\3^\3^\3^\5^\u0645\n^\3^\3^\3^\3^\3_\3") + buf.write("_\3_\7_\u064e\n_\f_\16_\u0651\13_\3`\3`\3`\3`\3`\3`\5") + buf.write("`\u0659\n`\3a\3a\3a\3a\3a\3a\3a\3a\5a\u0663\na\3a\3a\3") + buf.write("a\3a\3a\3a\3a\3a\3a\3a\3a\3b\3b\3b\7b\u0673\nb\fb\16b") + buf.write("\u0676\13b\3c\3c\5c\u067a\nc\3d\3d\5d\u067e\nd\3e\3e\3") + buf.write("e\3e\3e\3e\3e\3e\3e\5e\u0689\ne\3e\3e\3e\3e\5e\u068f\n") + buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\5f\u0699\nf\3f\3f\3f\3f\3f\5") + buf.write("f\u06a0\nf\3f\3f\3f\3f\3f\3f\5f\u06a8\nf\3g\3g\3g\7g\u06ad") + buf.write("\ng\fg\16g\u06b0\13g\3h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u06bb") + buf.write("\nh\3i\3i\3i\3i\3i\3i\3i\3i\3i\5i\u06c6\ni\3i\5i\u06c9") + buf.write("\ni\3i\3i\3i\3i\3j\3j\3j\7j\u06d2\nj\fj\16j\u06d5\13j") + buf.write("\3k\3k\5k\u06d9\nk\3l\3l\3l\3l\3l\3l\3l\3l\5l\u06e3\n") + buf.write("l\3l\3l\3l\3l\5l\u06e9\nl\3l\3l\3l\3l\3l\3l\3l\3l\3l\3") + buf.write("l\3l\3l\3m\3m\3m\7m\u06fa\nm\fm\16m\u06fd\13m\3n\3n\3") + buf.write("n\5n\u0702\nn\3o\3o\3o\3o\3o\3o\3o\3o\5o\u070c\no\3o\3") + buf.write("o\3o\3o\5o\u0712\no\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3") + buf.write("o\5o\u0720\no\3o\3o\3o\3o\3p\3p\3p\7p\u0729\np\fp\16p") + buf.write("\u072c\13p\3q\3q\5q\u0730\nq\3r\3r\3r\3r\3r\3r\3r\5r\u0739") + buf.write("\nr\3r\3r\3r\3r\3r\5r\u0740\nr\3r\3r\3r\3r\3s\3s\3s\7") + buf.write("s\u0749\ns\fs\16s\u074c\13s\3t\3t\3t\3t\5t\u0752\nt\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\5u\u075c\nu\3u\3u\3u\3u\3u\3u\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3") + buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\5u\u07a7\nu\3u\7") + buf.write("u\u07aa\nu\fu\16u\u07ad\13u\5u\u07af\nu\3u\3u\3u\3v\3") + buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\5v\u07c0\nv\3v\3v\3v\3") + buf.write("v\5v\u07c6\nv\3w\3w\3w\7w\u07cb\nw\fw\16w\u07ce\13w\3") + buf.write("x\3x\3y\3y\3y\3y\3y\3y\3y\3y\5y\u07da\ny\3y\3y\3y\3y\3") + buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3") + buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3") + buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3") + buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5y\u0825\n") + buf.write("y\3y\7y\u0828\ny\fy\16y\u082b\13y\5y\u082d\ny\3y\3y\3") + buf.write("y\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\5z\u083e\nz\3z\3") + buf.write("z\3z\3z\5z\u0844\nz\3{\3{\3{\7{\u0849\n{\f{\16{\u084c") + buf.write("\13{\3|\3|\3}\3}\3}\3}\5}\u0854\n}\3~\3~\3~\3~\3~\3\177") + buf.write("\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081") + buf.write("\3\u0081\3\u0081\5\u0081\u0865\n\u0081\3\u0082\3\u0082") + buf.write("\3\u0082\3\u0082\5\u0082\u086b\n\u0082\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\7\u0083\u0871\n\u0083\f\u0083\16\u0083") + buf.write("\u0874\13\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084") + buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\7\u0084\u087f\n\u0084") + buf.write("\f\u0084\16\u0084\u0882\13\u0084\3\u0084\3\u0084\5\u0084") + buf.write("\u0886\n\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085") + buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\7\u0085\u0891\n\u0085") + buf.write("\f\u0085\16\u0085\u0894\13\u0085\3\u0085\3\u0085\5\u0085") + buf.write("\u0898\n\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u08a3\n\u0086") + buf.write("\f\u0086\16\u0086\u08a6\13\u0086\3\u0086\3\u0086\5\u0086") + buf.write("\u08aa\n\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u08af\n") + buf.write("\u0086\f\u0086\16\u0086\u08b2\13\u0086\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087") + buf.write("\7\u0087\u08bd\n\u0087\f\u0087\16\u0087\u08c0\13\u0087") + buf.write("\3\u0087\3\u0087\5\u0087\u08c4\n\u0087\3\u0087\3\u0087") + buf.write("\3\u0087\7\u0087\u08c9\n\u0087\f\u0087\16\u0087\u08cc") + buf.write("\13\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\7\u0088\u08de\n\u0088\f\u0088") + buf.write("\16\u0088\u08e1\13\u0088\3\u0088\3\u0088\5\u0088\u08e5") + buf.write("\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089") + buf.write("\3\u0089\5\u0089\u08ee\n\u0089\3\u008a\3\u008a\3\u008a") + buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a") + buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\5\u008b\u090f\n\u008b\3\u008b\3\u008b\3\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\7\u008c\u092d\n\u008c\f\u008c") + buf.write("\16\u008c\u0930\13\u008c\5\u008c\u0932\n\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\5\u008c\u0938\n\u008c\3\u008c") + buf.write("\3\u008c\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e") + buf.write("\5\u008e\u0942\n\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e") + buf.write("\u0955\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f") + buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0962\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0968\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u096e\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0974\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u097a\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0980\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0986\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u098c\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0992\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f") + buf.write("\u0998\n\u008f\5\u008f\u099a\n\u008f\3\u008f\7\u008f\u099d") + buf.write("\n\u008f\f\u008f\16\u008f\u09a0\13\u008f\5\u008f\u09a2") + buf.write("\n\u008f\3\u008f\3\u008f\7\u008f\u09a6\n\u008f\f\u008f") + buf.write("\16\u008f\u09a9\13\u008f\3\u008f\5\u008f\u09ac\n\u008f") + buf.write("\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090") + buf.write("\5\u0090\u09b5\n\u0090\3\u0090\3\u0090\7\u0090\u09b9\n") + buf.write("\u0090\f\u0090\16\u0090\u09bc\13\u0090\3\u0090\3\u0090") + buf.write("\3\u0090\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093") + buf.write("\3\u0093\3\u0093\7\u0093\u09c9\n\u0093\f\u0093\16\u0093") + buf.write("\u09cc\13\u0093\3\u0094\3\u0094\3\u0094\7\u0094\u09d1") + buf.write("\n\u0094\f\u0094\16\u0094\u09d4\13\u0094\3\u0095\3\u0095") + buf.write("\3\u0095\7\u0095\u09d9\n\u0095\f\u0095\16\u0095\u09dc") + buf.write("\13\u0095\3\u0096\3\u0096\3\u0096\7\u0096\u09e1\n\u0096") + buf.write("\f\u0096\16\u0096\u09e4\13\u0096\3\u0097\3\u0097\3\u0097") + buf.write("\7\u0097\u09e9\n\u0097\f\u0097\16\u0097\u09ec\13\u0097") + buf.write("\3\u0098\3\u0098\7\u0098\u09f0\n\u0098\f\u0098\16\u0098") + buf.write("\u09f3\13\u0098\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099") + buf.write("\u09f9\n\u0099\3\u009a\3\u009a\7\u009a\u09fd\n\u009a\f") + buf.write("\u009a\16\u009a\u0a00\13\u009a\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u0a0a") + buf.write("\n\u009b\3\u009c\3\u009c\7\u009c\u0a0e\n\u009c\f\u009c") + buf.write("\16\u009c\u0a11\13\u009c\3\u009d\3\u009d\3\u009d\3\u009d") + buf.write("\5\u009d\u0a17\n\u009d\3\u009e\3\u009e\7\u009e\u0a1b\n") + buf.write("\u009e\f\u009e\16\u009e\u0a1e\13\u009e\3\u009f\3\u009f") + buf.write("\3\u009f\3\u009f\5\u009f\u0a24\n\u009f\3\u00a0\3\u00a0") + buf.write("\7\u00a0\u0a28\n\u00a0\f\u00a0\16\u00a0\u0a2b\13\u00a0") + buf.write("\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\5\u00a1") + buf.write("\u0a33\n\u00a1\3\u00a2\3\u00a2\3\u00a2\7\u00a2\u0a38\n") + buf.write("\u00a2\f\u00a2\16\u00a2\u0a3b\13\u00a2\3\u00a2\3\u00a2") + buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3") + buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u0a4b") + buf.write("\n\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4") + buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5") + buf.write("\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6") + buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7") + buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0a73\n\u00a8") + buf.write("\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa") + buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa") + buf.write("\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0a86\n\u00aa\3\u00ab") + buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab") + buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0a94\n\u00ab") + buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac") + buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0aa2") + buf.write("\n\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\6\u00ad\u0aa8") + buf.write("\n\u00ad\r\u00ad\16\u00ad\u0aa9\3\u00ae\3\u00ae\3\u00ae") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae\u0ab3\n\u00ae") + buf.write("\f\u00ae\16\u00ae\u0ab6\13\u00ae\5\u00ae\u0ab8\n\u00ae") + buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u0abe\n\u00af") + buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1") + buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u0ad1\n\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4") + buf.write("\3\u00b4\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6") + buf.write("\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0ae5\n\u00b6\3\u00b6") + buf.write("\3\u00b6\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\5\u00b8") + buf.write("\u0af5\n\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9") + buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb") + buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb") + buf.write("\5\u00bb\u0b0a\n\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb") + buf.write("\3\u00bb\5\u00bb\u0b11\n\u00bb\3\u00bb\3\u00bb\3\u00bb") + buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd") + buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be\3\u00be") + buf.write("\3\u00be\5\u00be\u0b25\n\u00be\3\u00be\3\u00be\3\u00be") + buf.write("\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0") + buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1") + buf.write("\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2") + buf.write("\3\u00c2\3\u00c2\5\u00c2\u0b41\n\u00c2\3\u00c2\3\u00c2") + buf.write("\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3") + buf.write("\5\u00c3\u0b4c\n\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4") + buf.write("\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5") + buf.write("\3\u00c5\3\u00c5\3\u00c5\7\u00c5\u0b5c\n\u00c5\f\u00c5") + buf.write("\16\u00c5\u0b5f\13\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5") + buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c7") + buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7") + buf.write("\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8") + buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9") + buf.write("\3\u00c9\3\u00c9\3\u00c9\7\u00c9\u0b84\n\u00c9\f\u00c9") + buf.write("\16\u00c9\u0b87\13\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9") + buf.write("\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\7\u00cb\u0b9c\n\u00cb\f\u00cb\16\u00cb\u0b9f") + buf.write("\13\u00cb\3\u00cb\3\u00cb\3\u00cb\2\2\u00cc\2\4\6\b\n") + buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<") + buf.write(">@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086") + buf.write("\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098") + buf.write("\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa") + buf.write("\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc") + buf.write("\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce") + buf.write("\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0") + buf.write("\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2") + buf.write("\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104") + buf.write("\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116") + buf.write("\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128") + buf.write("\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a") + buf.write("\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c") + buf.write("\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e") + buf.write("\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170") + buf.write("\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182") + buf.write("\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194") + buf.write("\2\20\3\2\4\5\4\2\u00ac\u00b2\u00fa\u00fa\4\2\u00b3\u00b6") + buf.write("\u00fa\u00fa\4\2\n\n\u00fa\u00fa\5\2\u00b7\u00b9\u00bd") + buf.write("\u00bf\u00fa\u00fa\4\2\u00ba\u00bf\u00fa\u00fa\3\2\u0085") + buf.write("\u0086\3\2\u008a\u008c\3\2RV\3\2\u00fa\u00fb\3\2\u00ef") + buf.write("\u00f2\4\2\u00d3\u00d9\u00fa\u00fa\3\2\u00f6\u00f7\3\2") + buf.write("\u00f8\u00fa\2\u0c6e\2\u019b\3\2\2\2\4\u01a0\3\2\2\2\6") + buf.write("\u01a2\3\2\2\2\b\u01ac\3\2\2\2\n\u01ae\3\2\2\2\f\u01b9") + buf.write("\3\2\2\2\16\u01cb\3\2\2\2\20\u01ec\3\2\2\2\22\u01ef\3") + buf.write("\2\2\2\24\u01f8\3\2\2\2\26\u0201\3\2\2\2\30\u020a\3\2") + buf.write("\2\2\32\u0213\3\2\2\2\34\u021c\3\2\2\2\36\u0225\3\2\2") + buf.write("\2 \u022e\3\2\2\2\"\u0237\3\2\2\2$\u0240\3\2\2\2&\u0249") + buf.write("\3\2\2\2(\u0251\3\2\2\2*\u0259\3\2\2\2,\u0261\3\2\2\2") + buf.write(".\u0269\3\2\2\2\60\u0295\3\2\2\2\62\u02a2\3\2\2\2\64\u02aa") + buf.write("\3\2\2\2\66\u02ac\3\2\2\28\u02b1\3\2\2\2:\u02be\3\2\2") + buf.write("\2<\u02c0\3\2\2\2>\u02d1\3\2\2\2@\u02f3\3\2\2\2B\u032d") + buf.write("\3\2\2\2D\u032f\3\2\2\2F\u0348\3\2\2\2H\u034f\3\2\2\2") + buf.write("J\u0356\3\2\2\2L\u0366\3\2\2\2N\u0376\3\2\2\2P\u037b\3") + buf.write("\2\2\2R\u0382\3\2\2\2T\u0391\3\2\2\2V\u03a7\3\2\2\2X\u03b5") + buf.write("\3\2\2\2Z\u03e3\3\2\2\2\\\u03e5\3\2\2\2^\u03ec\3\2\2\2") + buf.write("`\u03f0\3\2\2\2b\u03f2\3\2\2\2d\u03fa\3\2\2\2f\u041e\3") + buf.write("\2\2\2h\u0420\3\2\2\2j\u043f\3\2\2\2l\u0442\3\2\2\2n\u0445") + buf.write("\3\2\2\2p\u044f\3\2\2\2r\u0451\3\2\2\2t\u0476\3\2\2\2") + buf.write("v\u0478\3\2\2\2x\u0480\3\2\2\2z\u0482\3\2\2\2|\u04b3\3") + buf.write("\2\2\2~\u04b7\3\2\2\2\u0080\u04b9\3\2\2\2\u0082\u04fe") + buf.write("\3\2\2\2\u0084\u0508\3\2\2\2\u0086\u050a\3\2\2\2\u0088") + buf.write("\u051f\3\2\2\2\u008a\u052c\3\2\2\2\u008c\u052e\3\2\2\2") + buf.write("\u008e\u0549\3\2\2\2\u0090\u0564\3\2\2\2\u0092\u056c\3") + buf.write("\2\2\2\u0094\u0571\3\2\2\2\u0096\u0579\3\2\2\2\u0098\u057e") + buf.write("\3\2\2\2\u009a\u0594\3\2\2\2\u009c\u059e\3\2\2\2\u009e") + buf.write("\u05a8\3\2\2\2\u00a0\u05aa\3\2\2\2\u00a2\u05c0\3\2\2\2") + buf.write("\u00a4\u05d6\3\2\2\2\u00a6\u05e6\3\2\2\2\u00a8\u05ea\3") + buf.write("\2\2\2\u00aa\u05ec\3\2\2\2\u00ac\u060a\3\2\2\2\u00ae\u061d") + buf.write("\3\2\2\2\u00b0\u061f\3\2\2\2\u00b2\u0623\3\2\2\2\u00b4") + buf.write("\u062a\3\2\2\2\u00b6\u062f\3\2\2\2\u00b8\u0633\3\2\2\2") + buf.write("\u00ba\u0635\3\2\2\2\u00bc\u064a\3\2\2\2\u00be\u0658\3") + buf.write("\2\2\2\u00c0\u065a\3\2\2\2\u00c2\u066f\3\2\2\2\u00c4\u0679") + buf.write("\3\2\2\2\u00c6\u067d\3\2\2\2\u00c8\u067f\3\2\2\2\u00ca") + buf.write("\u0695\3\2\2\2\u00cc\u06a9\3\2\2\2\u00ce\u06ba\3\2\2\2") + buf.write("\u00d0\u06bc\3\2\2\2\u00d2\u06ce\3\2\2\2\u00d4\u06d8\3") + buf.write("\2\2\2\u00d6\u06da\3\2\2\2\u00d8\u06f6\3\2\2\2\u00da\u0701") + buf.write("\3\2\2\2\u00dc\u0703\3\2\2\2\u00de\u0725\3\2\2\2\u00e0") + buf.write("\u072f\3\2\2\2\u00e2\u0731\3\2\2\2\u00e4\u0745\3\2\2\2") + buf.write("\u00e6\u0751\3\2\2\2\u00e8\u0753\3\2\2\2\u00ea\u07b3\3") + buf.write("\2\2\2\u00ec\u07c7\3\2\2\2\u00ee\u07cf\3\2\2\2\u00f0\u07d1") + buf.write("\3\2\2\2\u00f2\u0831\3\2\2\2\u00f4\u0845\3\2\2\2\u00f6") + buf.write("\u084d\3\2\2\2\u00f8\u0853\3\2\2\2\u00fa\u0855\3\2\2\2") + buf.write("\u00fc\u085a\3\2\2\2\u00fe\u085c\3\2\2\2\u0100\u0864\3") + buf.write("\2\2\2\u0102\u086a\3\2\2\2\u0104\u086c\3\2\2\2\u0106\u0878") + buf.write("\3\2\2\2\u0108\u088a\3\2\2\2\u010a\u089c\3\2\2\2\u010c") + buf.write("\u08b6\3\2\2\2\u010e\u08d0\3\2\2\2\u0110\u08ed\3\2\2\2") + buf.write("\u0112\u08ef\3\2\2\2\u0114\u08f9\3\2\2\2\u0116\u0912\3") + buf.write("\2\2\2\u0118\u093b\3\2\2\2\u011a\u093f\3\2\2\2\u011c\u0956") + buf.write("\3\2\2\2\u011e\u09af\3\2\2\2\u0120\u09c0\3\2\2\2\u0122") + buf.write("\u09c3\3\2\2\2\u0124\u09c5\3\2\2\2\u0126\u09cd\3\2\2\2") + buf.write("\u0128\u09d5\3\2\2\2\u012a\u09dd\3\2\2\2\u012c\u09e5\3") + buf.write("\2\2\2\u012e\u09ed\3\2\2\2\u0130\u09f8\3\2\2\2\u0132\u09fa") + buf.write("\3\2\2\2\u0134\u0a09\3\2\2\2\u0136\u0a0b\3\2\2\2\u0138") + buf.write("\u0a16\3\2\2\2\u013a\u0a18\3\2\2\2\u013c\u0a23\3\2\2\2") + buf.write("\u013e\u0a25\3\2\2\2\u0140\u0a32\3\2\2\2\u0142\u0a39\3") + buf.write("\2\2\2\u0144\u0a4a\3\2\2\2\u0146\u0a4c\3\2\2\2\u0148\u0a53") + buf.write("\3\2\2\2\u014a\u0a5a\3\2\2\2\u014c\u0a63\3\2\2\2\u014e") + buf.write("\u0a72\3\2\2\2\u0150\u0a74\3\2\2\2\u0152\u0a76\3\2\2\2") + buf.write("\u0154\u0a87\3\2\2\2\u0156\u0a95\3\2\2\2\u0158\u0aa3\3") + buf.write("\2\2\2\u015a\u0ab7\3\2\2\2\u015c\u0ab9\3\2\2\2\u015e\u0abf") + buf.write("\3\2\2\2\u0160\u0ac4\3\2\2\2\u0162\u0ac9\3\2\2\2\u0164") + buf.write("\u0ad4\3\2\2\2\u0166\u0ad6\3\2\2\2\u0168\u0adb\3\2\2\2") + buf.write("\u016a\u0add\3\2\2\2\u016c\u0ae8\3\2\2\2\u016e\u0af4\3") + buf.write("\2\2\2\u0170\u0af6\3\2\2\2\u0172\u0afb\3\2\2\2\u0174\u0b00") + buf.write("\3\2\2\2\u0176\u0b15\3\2\2\2\u0178\u0b1a\3\2\2\2\u017a") + buf.write("\u0b1f\3\2\2\2\u017c\u0b2a\3\2\2\2\u017e\u0b2f\3\2\2\2") + buf.write("\u0180\u0b34\3\2\2\2\u0182\u0b39\3\2\2\2\u0184\u0b4b\3") + buf.write("\2\2\2\u0186\u0b4d\3\2\2\2\u0188\u0b56\3\2\2\2\u018a\u0b68") + buf.write("\3\2\2\2\u018c\u0b6a\3\2\2\2\u018e\u0b73\3\2\2\2\u0190") + buf.write("\u0b7c\3\2\2\2\u0192\u0b90\3\2\2\2\u0194\u0b92\3\2\2\2") + buf.write("\u0196\u019a\5\n\6\2\u0197\u019a\5\f\7\2\u0198\u019a\5") + buf.write("\16\b\2\u0199\u0196\3\2\2\2\u0199\u0197\3\2\2\2\u0199") + buf.write("\u0198\3\2\2\2\u019a\u019d\3\2\2\2\u019b\u0199\3\2\2\2") + buf.write("\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3") + buf.write("\2\2\2\u019e\u019f\5.\30\2\u019f\3\3\2\2\2\u01a0\u01a1") + buf.write("\7\3\2\2\u01a1\5\3\2\2\2\u01a2\u01a5\t\2\2\2\u01a3\u01a4") + buf.write("\7!\2\2\u01a4\u01a6\7\u00fb\2\2\u01a5\u01a3\3\2\2\2\u01a5") + buf.write("\u01a6\3\2\2\2\u01a6\u01a9\3\2\2\2\u01a7\u01a8\7!\2\2") + buf.write("\u01a8\u01aa\7\u00fa\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa") + buf.write("\3\2\2\2\u01aa\7\3\2\2\2\u01ab\u01ad\7\u00fa\2\2\u01ac") + buf.write("\u01ab\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\t\3\2\2\2\u01ae") + buf.write("\u01af\7\6\2\2\u01af\u01b0\7\7\2\2\u01b0\u01b4\7\30\2") + buf.write("\2\u01b1\u01b5\5\4\3\2\u01b2\u01b5\5\6\4\2\u01b3\u01b5") + buf.write("\5\b\5\2\u01b4\u01b1\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b4") + buf.write("\u01b3\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b6\3\2\2\2") + buf.write("\u01b6\u01b7\7\31\2\2\u01b7\13\3\2\2\2\u01b8\u01ba\7\u0084") + buf.write("\2\2\u01b9\u01b8\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb") + buf.write("\3\2\2\2\u01bb\u01bd\7P\2\2\u01bc\u01be\7O\2\2\u01bd\u01bc") + buf.write("\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01c0\3\2\2\2\u01bf") + buf.write("\u01c1\7\u00fb\2\2\u01c0\u01bf\3\2\2\2\u01c0\u01c1\3\2") + buf.write("\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c3\7\26\2\2\u01c3\u01c4") + buf.write("\5\20\t\2\u01c4\u01c6\7\27\2\2\u01c5\u01c7\7\u00fb\2\2") + buf.write("\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3") + buf.write("\2\2\2\u01c8\u01c9\7 \2\2\u01c9\r\3\2\2\2\u01ca\u01cc") + buf.write("\7\u0084\2\2\u01cb\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc") + buf.write("\u01cd\3\2\2\2\u01cd\u01cf\7Q\2\2\u01ce\u01d0\7O\2\2\u01cf") + buf.write("\u01ce\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2\3\2\2\2") + buf.write("\u01d1\u01d3\7\u00fb\2\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3") + buf.write("\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5\7\26\2\2\u01d5") + buf.write("\u01d6\5\20\t\2\u01d6\u01d8\7\27\2\2\u01d7\u01d9\7\u00fb") + buf.write("\2\2\u01d8\u01d7\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da") + buf.write("\3\2\2\2\u01da\u01db\7 \2\2\u01db\17\3\2\2\2\u01dc\u01eb") + buf.write("\5\22\n\2\u01dd\u01eb\5\24\13\2\u01de\u01eb\5\26\f\2\u01df") + buf.write("\u01eb\5\30\r\2\u01e0\u01eb\5\32\16\2\u01e1\u01eb\5\34") + buf.write("\17\2\u01e2\u01eb\5\36\20\2\u01e3\u01eb\5 \21\2\u01e4") + buf.write("\u01eb\5\"\22\2\u01e5\u01eb\5$\23\2\u01e6\u01eb\5&\24") + buf.write("\2\u01e7\u01eb\5(\25\2\u01e8\u01eb\5*\26\2\u01e9\u01eb") + buf.write("\5,\27\2\u01ea\u01dc\3\2\2\2\u01ea\u01dd\3\2\2\2\u01ea") + buf.write("\u01de\3\2\2\2\u01ea\u01df\3\2\2\2\u01ea\u01e0\3\2\2\2") + buf.write("\u01ea\u01e1\3\2\2\2\u01ea\u01e2\3\2\2\2\u01ea\u01e3\3") + buf.write("\2\2\2\u01ea\u01e4\3\2\2\2\u01ea\u01e5\3\2\2\2\u01ea\u01e6") + buf.write("\3\2\2\2\u01ea\u01e7\3\2\2\2\u01ea\u01e8\3\2\2\2\u01ea") + buf.write("\u01e9\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2") + buf.write("\u01ec\u01ed\3\2\2\2\u01ed\21\3\2\2\2\u01ee\u01ec\3\2") + buf.write("\2\2\u01ef\u01f0\7S\2\2\u01f0\u01f4\7\u00fb\2\2\u01f1") + buf.write("\u01f2\7\32\2\2\u01f2\u01f3\7\u00fa\2\2\u01f3\u01f5\7") + buf.write("\33\2\2\u01f4\u01f1\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5") + buf.write("\u01f6\3\2\2\2\u01f6\u01f7\7 \2\2\u01f7\23\3\2\2\2\u01f8") + buf.write("\u01f9\7T\2\2\u01f9\u01fd\7\u00fb\2\2\u01fa\u01fb\7\32") + buf.write("\2\2\u01fb\u01fc\7\u00fa\2\2\u01fc\u01fe\7\33\2\2\u01fd") + buf.write("\u01fa\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01ff\3\2\2\2") + buf.write("\u01ff\u0200\7 \2\2\u0200\25\3\2\2\2\u0201\u0202\7U\2") + buf.write("\2\u0202\u0206\7\u00fb\2\2\u0203\u0204\7\32\2\2\u0204") + buf.write("\u0205\7\u00fa\2\2\u0205\u0207\7\33\2\2\u0206\u0203\3") + buf.write("\2\2\2\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209") + buf.write("\7 \2\2\u0209\27\3\2\2\2\u020a\u020b\7V\2\2\u020b\u020f") + buf.write("\7\u00fb\2\2\u020c\u020d\7\32\2\2\u020d\u020e\7\u00fa") + buf.write("\2\2\u020e\u0210\7\33\2\2\u020f\u020c\3\2\2\2\u020f\u0210") + buf.write("\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0212\7 \2\2\u0212") + buf.write("\31\3\2\2\2\u0213\u0214\7R\2\2\u0214\u0218\7\u00fb\2\2") + buf.write("\u0215\u0216\7\32\2\2\u0216\u0217\7\u00fa\2\2\u0217\u0219") + buf.write("\7\33\2\2\u0218\u0215\3\2\2\2\u0218\u0219\3\2\2\2\u0219") + buf.write("\u021a\3\2\2\2\u021a\u021b\7 \2\2\u021b\33\3\2\2\2\u021c") + buf.write("\u021d\7W\2\2\u021d\u0221\7\u00fb\2\2\u021e\u021f\7\32") + buf.write("\2\2\u021f\u0220\7\u00fa\2\2\u0220\u0222\7\33\2\2\u0221") + buf.write("\u021e\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0223\3\2\2\2") + buf.write("\u0223\u0224\7 \2\2\u0224\35\3\2\2\2\u0225\u0226\7X\2") + buf.write("\2\u0226\u022a\7\u00fb\2\2\u0227\u0228\7\32\2\2\u0228") + buf.write("\u0229\7\u00fa\2\2\u0229\u022b\7\33\2\2\u022a\u0227\3") + buf.write("\2\2\2\u022a\u022b\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022d") + buf.write("\7 \2\2\u022d\37\3\2\2\2\u022e\u022f\7Y\2\2\u022f\u0233") + buf.write("\7\u00fb\2\2\u0230\u0231\7\32\2\2\u0231\u0232\7\u00fa") + buf.write("\2\2\u0232\u0234\7\33\2\2\u0233\u0230\3\2\2\2\u0233\u0234") + buf.write("\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\7 \2\2\u0236") + buf.write("!\3\2\2\2\u0237\u0238\7Z\2\2\u0238\u023c\7\u00fb\2\2\u0239") + buf.write("\u023a\7\32\2\2\u023a\u023b\7\u00fa\2\2\u023b\u023d\7") + buf.write("\33\2\2\u023c\u0239\3\2\2\2\u023c\u023d\3\2\2\2\u023d") + buf.write("\u023e\3\2\2\2\u023e\u023f\7 \2\2\u023f#\3\2\2\2\u0240") + buf.write("\u0241\7\u00fb\2\2\u0241\u0245\7\u00fb\2\2\u0242\u0243") + buf.write("\7\32\2\2\u0243\u0244\7\u00fa\2\2\u0244\u0246\7\33\2\2") + buf.write("\u0245\u0242\3\2\2\2\u0245\u0246\3\2\2\2\u0246\u0247\3") + buf.write("\2\2\2\u0247\u0248\7 \2\2\u0248%\3\2\2\2\u0249\u024b\7") + buf.write("S\2\2\u024a\u024c\7\u00fb\2\2\u024b\u024a\3\2\2\2\u024b") + buf.write("\u024c\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024e\7\36\2") + buf.write("\2\u024e\u024f\7\u00fa\2\2\u024f\u0250\7 \2\2\u0250\'") + buf.write("\3\2\2\2\u0251\u0253\7T\2\2\u0252\u0254\7\u00fb\2\2\u0253") + buf.write("\u0252\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0255\3\2\2\2") + buf.write("\u0255\u0256\7\36\2\2\u0256\u0257\7\u00fa\2\2\u0257\u0258") + buf.write("\7 \2\2\u0258)\3\2\2\2\u0259\u025b\7U\2\2\u025a\u025c") + buf.write("\7\u00fb\2\2\u025b\u025a\3\2\2\2\u025b\u025c\3\2\2\2\u025c") + buf.write("\u025d\3\2\2\2\u025d\u025e\7\36\2\2\u025e\u025f\7\u00fa") + buf.write("\2\2\u025f\u0260\7 \2\2\u0260+\3\2\2\2\u0261\u0263\7V") + buf.write("\2\2\u0262\u0264\7\u00fb\2\2\u0263\u0262\3\2\2\2\u0263") + buf.write("\u0264\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0266\7\36\2") + buf.write("\2\u0266\u0267\7\u00fa\2\2\u0267\u0268\7 \2\2\u0268-\3") + buf.write("\2\2\2\u0269\u026a\7+\2\2\u026a\u026b\7[\2\2\u026b\u026c") + buf.write("\7\b\2\2\u026c\u026d\5L\'\2\u026d\u026e\7!\2\2\u026e\u026f") + buf.write("\7.\2\2\u026f\u0270\7\b\2\2\u0270\u0271\7\u00ec\2\2\u0271") + buf.write("\u0272\7\30\2\2\u0272\u0273\7\u00fa\2\2\u0273\u0274\7") + buf.write("\31\2\2\u0274\u0275\7!\2\2\u0275\u0276\7=\2\2\u0276\u0277") + buf.write("\7\b\2\2\u0277\u0278\7\u00ec\2\2\u0278\u0279\7\30\2\2") + buf.write("\u0279\u027a\7\u00fa\2\2\u027a\u027b\7\31\2\2\u027b\u0281") + buf.write("\7!\2\2\u027c\u027d\7\u0083\2\2\u027d\u027e\7\b\2\2\u027e") + buf.write("\u027f\5\60\31\2\u027f\u0280\7!\2\2\u0280\u0282\3\2\2") + buf.write("\2\u0281\u027c\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0288") + buf.write("\3\2\2\2\u0283\u0284\7\u0081\2\2\u0284\u0285\7\b\2\2\u0285") + buf.write("\u0286\5\62\32\2\u0286\u0287\7!\2\2\u0287\u0289\3\2\2") + buf.write("\2\u0288\u0283\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u028f") + buf.write("\3\2\2\2\u028a\u028b\7\u0082\2\2\u028b\u028c\7\b\2\2\u028c") + buf.write("\u028d\5\66\34\2\u028d\u028e\7!\2\2\u028e\u0290\3\2\2") + buf.write("\2\u028f\u028a\3\2\2\2\u028f\u0290\3\2\2\2\u0290\u0291") + buf.write("\3\2\2\2\u0291\u0292\58\35\2\u0292\u0293\7-\2\2\u0293") + buf.write("\u0294\7 \2\2\u0294/\3\2\2\2\u0295\u0298\5L\'\2\u0296") + buf.write("\u0297\7(\2\2\u0297\u0299\5L\'\2\u0298\u0296\3\2\2\2\u0298") + buf.write("\u0299\3\2\2\2\u0299\u029c\3\2\2\2\u029a\u029b\7(\2\2") + buf.write("\u029b\u029d\5L\'\2\u029c\u029a\3\2\2\2\u029c\u029d\3") + buf.write("\2\2\2\u029d\u02a0\3\2\2\2\u029e\u029f\7(\2\2\u029f\u02a1") + buf.write("\5L\'\2\u02a0\u029e\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1") + buf.write("\61\3\2\2\2\u02a2\u02a7\5\64\33\2\u02a3\u02a4\7(\2\2\u02a4") + buf.write("\u02a6\5\64\33\2\u02a5\u02a3\3\2\2\2\u02a6\u02a9\3\2\2") + buf.write("\2\u02a7\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\63\3") + buf.write("\2\2\2\u02a9\u02a7\3\2\2\2\u02aa\u02ab\t\3\2\2\u02ab\65") + buf.write("\3\2\2\2\u02ac\u02ad\t\4\2\2\u02ad\67\3\2\2\2\u02ae\u02b0") + buf.write("\5:\36\2\u02af\u02ae\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1") + buf.write("\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b29\3\2\2\2\u02b3") + buf.write("\u02b1\3\2\2\2\u02b4\u02bf\5d\63\2\u02b5\u02bf\5h\65\2") + buf.write("\u02b6\u02bf\5j\66\2\u02b7\u02bf\5> \2\u02b8\u02bf\5@") + buf.write("!\2\u02b9\u02bf\5D#\2\u02ba\u02bf\5<\37\2\u02bb\u02bf") + buf.write("\5F$\2\u02bc\u02bf\5H%\2\u02bd\u02bf\5\u011c\u008f\2\u02be") + buf.write("\u02b4\3\2\2\2\u02be\u02b5\3\2\2\2\u02be\u02b6\3\2\2\2") + buf.write("\u02be\u02b7\3\2\2\2\u02be\u02b8\3\2\2\2\u02be\u02b9\3") + buf.write("\2\2\2\u02be\u02ba\3\2\2\2\u02be\u02bb\3\2\2\2\u02be\u02bc") + buf.write("\3\2\2\2\u02be\u02bd\3\2\2\2\u02bf;\3\2\2\2\u02c0\u02c1") + buf.write("\7\u009b\2\2\u02c1\u02c2\7\u00fb\2\2\u02c2\u02c3\7!\2") + buf.write("\2\u02c3\u02c4\7\62\2\2\u02c4\u02c5\7\b\2\2\u02c5\u02c6") + buf.write("\7\u00ec\2\2\u02c6\u02c7\7\30\2\2\u02c7\u02c8\7\u00fa") + buf.write("\2\2\u02c8\u02cd\7\31\2\2\u02c9\u02ca\7!\2\2\u02ca\u02cb") + buf.write("\7\u009c\2\2\u02cb\u02cc\7\b\2\2\u02cc\u02ce\7\u00fa\2") + buf.write("\2\u02cd\u02c9\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf") + buf.write("\3\2\2\2\u02cf\u02d0\7 \2\2\u02d0=\3\2\2\2\u02d1\u02e2") + buf.write("\7\u009d\2\2\u02d2\u02d3\7\u00fb\2\2\u02d3\u02e3\7!\2") + buf.write("\2\u02d4\u02d5\7V\2\2\u02d5\u02e3\7!\2\2\u02d6\u02d7\7") + buf.write("U\2\2\u02d7\u02e3\7!\2\2\u02d8\u02d9\7T\2\2\u02d9\u02e3") + buf.write("\7!\2\2\u02da\u02db\7S\2\2\u02db\u02e3\7!\2\2\u02dc\u02dd") + buf.write("\7X\2\2\u02dd\u02e3\7!\2\2\u02de\u02df\7Y\2\2\u02df\u02e3") + buf.write("\7!\2\2\u02e0\u02e1\7Z\2\2\u02e1\u02e3\7!\2\2\u02e2\u02d2") + buf.write("\3\2\2\2\u02e2\u02d4\3\2\2\2\u02e2\u02d6\3\2\2\2\u02e2") + buf.write("\u02d8\3\2\2\2\u02e2\u02da\3\2\2\2\u02e2\u02dc\3\2\2\2") + buf.write("\u02e2\u02de\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3\u02e8\3") + buf.write("\2\2\2\u02e4\u02e5\7\u008f\2\2\u02e5\u02e6\7\b\2\2\u02e6") + buf.write("\u02e7\7\u00fa\2\2\u02e7\u02e9\7!\2\2\u02e8\u02e4\3\2") + buf.write("\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02eb") + buf.write("\7\u008e\2\2\u02eb\u02ec\7\b\2\2\u02ec\u02ed\7\u00fb\2") + buf.write("\2\u02ed\u02ee\7!\2\2\u02ee\u02ef\7[\2\2\u02ef\u02f0\7") + buf.write("\b\2\2\u02f0\u02f1\5L\'\2\u02f1\u02f2\7 \2\2\u02f2?\3") + buf.write("\2\2\2\u02f3\u0304\7\u009e\2\2\u02f4\u02f5\7\u00fb\2\2") + buf.write("\u02f5\u0305\7!\2\2\u02f6\u02f7\7V\2\2\u02f7\u0305\7!") + buf.write("\2\2\u02f8\u02f9\7U\2\2\u02f9\u0305\7!\2\2\u02fa\u02fb") + buf.write("\7T\2\2\u02fb\u0305\7!\2\2\u02fc\u02fd\7S\2\2\u02fd\u0305") + buf.write("\7!\2\2\u02fe\u02ff\7X\2\2\u02ff\u0305\7!\2\2\u0300\u0301") + buf.write("\7Y\2\2\u0301\u0305\7!\2\2\u0302\u0303\7Z\2\2\u0303\u0305") + buf.write("\7!\2\2\u0304\u02f4\3\2\2\2\u0304\u02f6\3\2\2\2\u0304") + buf.write("\u02f8\3\2\2\2\u0304\u02fa\3\2\2\2\u0304\u02fc\3\2\2\2") + buf.write("\u0304\u02fe\3\2\2\2\u0304\u0300\3\2\2\2\u0304\u0302\3") + buf.write("\2\2\2\u0305\u030a\3\2\2\2\u0306\u0307\7\u008f\2\2\u0307") + buf.write("\u0308\7\b\2\2\u0308\u0309\7\u00fa\2\2\u0309\u030b\7!") + buf.write("\2\2\u030a\u0306\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030c") + buf.write("\3\2\2\2\u030c\u030d\7\u009c\2\2\u030d\u030e\7\b\2\2\u030e") + buf.write("\u0313\5B\"\2\u030f\u0310\7(\2\2\u0310\u0312\5B\"\2\u0311") + buf.write("\u030f\3\2\2\2\u0312\u0315\3\2\2\2\u0313\u0311\3\2\2\2") + buf.write("\u0313\u0314\3\2\2\2\u0314\u0316\3\2\2\2\u0315\u0313\3") + buf.write("\2\2\2\u0316\u0326\7!\2\2\u0317\u0318\7\u008e\2\2\u0318") + buf.write("\u0319\7\b\2\2\u0319\u031a\7\u00fb\2\2\u031a\u0327\7!") + buf.write("\2\2\u031b\u031c\7\u008e\2\2\u031c\u031d\7\b\2\2\u031d") + buf.write("\u031e\7\u00ec\2\2\u031e\u031f\7\30\2\2\u031f\u0320\7") + buf.write("\u00fa\2\2\u0320\u0321\7\31\2\2\u0321\u0322\7!\2\2\u0322") + buf.write("\u0323\7\u009f\2\2\u0323\u0324\7\b\2\2\u0324\u0325\7\u00fa") + buf.write("\2\2\u0325\u0327\7!\2\2\u0326\u0317\3\2\2\2\u0326\u031b") + buf.write("\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\7[\2\2\u0329") + buf.write("\u032a\7\b\2\2\u032a\u032b\5L\'\2\u032b\u032c\7 \2\2\u032c") + buf.write("A\3\2\2\2\u032d\u032e\7\u00fa\2\2\u032eC\3\2\2\2\u032f") + buf.write("\u0330\7\u00a0\2\2\u0330\u0331\7\u00fb\2\2\u0331\u0336") + buf.write("\7!\2\2\u0332\u0333\7\u008f\2\2\u0333\u0334\7\b\2\2\u0334") + buf.write("\u0335\7\u00fa\2\2\u0335\u0337\7!\2\2\u0336\u0332\3\2") + buf.write("\2\2\u0336\u0337\3\2\2\2\u0337\u033f\3\2\2\2\u0338\u0339") + buf.write("\7\u008e\2\2\u0339\u033a\7\b\2\2\u033a\u033b\7\u00ec\2") + buf.write("\2\u033b\u033c\7\30\2\2\u033c\u033d\7\u00fa\2\2\u033d") + buf.write("\u033e\7\31\2\2\u033e\u0340\7!\2\2\u033f\u0338\3\2\2\2") + buf.write("\u0340\u0341\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3") + buf.write("\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344\7[\2\2\u0344\u0345") + buf.write("\7\b\2\2\u0345\u0346\5L\'\2\u0346\u0347\7 \2\2\u0347E") + buf.write("\3\2\2\2\u0348\u0349\7l\2\2\u0349\u034a\5\u0124\u0093") + buf.write("\2\u034a\u034b\7 \2\2\u034b\u034c\58\35\2\u034c\u034d") + buf.write("\7s\2\2\u034d\u034e\7 \2\2\u034eG\3\2\2\2\u034f\u0350") + buf.write("\7k\2\2\u0350\u0351\5\u0124\u0093\2\u0351\u0352\7 \2\2") + buf.write("\u0352\u0353\58\35\2\u0353\u0354\7s\2\2\u0354\u0355\7") + buf.write(" \2\2\u0355I\3\2\2\2\u0356\u0357\7\u00fa\2\2\u0357\u0358") + buf.write("\7!\2\2\u0358\u0359\7\u00fa\2\2\u0359\u035a\7!\2\2\u035a") + buf.write("\u035b\7\u00fa\2\2\u035b\u035c\7!\2\2\u035c\u035d\7\u00fa") + buf.write("\2\2\u035d\u035e\7!\2\2\u035e\u035f\7\u00fa\2\2\u035f") + buf.write("\u0360\7!\2\2\u0360\u0361\7\u00fa\2\2\u0361\u0362\7!\2") + buf.write("\2\u0362\u0363\7\u00fa\2\2\u0363\u0364\7!\2\2\u0364\u0365") + buf.write("\7\u00fa\2\2\u0365K\3\2\2\2\u0366\u0367\7\26\2\2\u0367") + buf.write("\u0368\7\u00fa\2\2\u0368\u0369\7!\2\2\u0369\u036a\7\u00fa") + buf.write("\2\2\u036a\u036b\7!\2\2\u036b\u036c\7\u00fa\2\2\u036c") + buf.write("\u0372\7!\2\2\u036d\u036e\7\26\2\2\u036e\u036f\5J&\2\u036f") + buf.write("\u0370\7\27\2\2\u0370\u0373\3\2\2\2\u0371\u0373\5J&\2") + buf.write("\u0372\u036d\3\2\2\2\u0372\u0371\3\2\2\2\u0373\u0374\3") + buf.write("\2\2\2\u0374\u0375\7\27\2\2\u0375M\3\2\2\2\u0376\u0377") + buf.write("\7\u00ec\2\2\u0377\u0378\7\30\2\2\u0378\u0379\7\u00fa") + buf.write("\2\2\u0379\u037a\7\31\2\2\u037aO\3\2\2\2\u037b\u037c\5") + buf.write("R*\2\u037c\u037d\5T+\2\u037dQ\3\2\2\2\u037e\u037f\7\u008e") + buf.write("\2\2\u037f\u0380\7\b\2\2\u0380\u0381\7\u00fb\2\2\u0381") + buf.write("\u0383\7!\2\2\u0382\u037e\3\2\2\2\u0382\u0383\3\2\2\2") + buf.write("\u0383\u0389\3\2\2\2\u0384\u0385\7\u008f\2\2\u0385\u0386") + buf.write("\7\b\2\2\u0386\u0387\5X-\2\u0387\u0388\7!\2\2\u0388\u038a") + buf.write("\3\2\2\2\u0389\u0384\3\2\2\2\u0389\u038a\3\2\2\2\u038a") + buf.write("\u038f\3\2\2\2\u038b\u038c\7\u0091\2\2\u038c\u038d\7\b") + buf.write("\2\2\u038d\u038e\7\u00fa\2\2\u038e\u0390\7!\2\2\u038f") + buf.write("\u038b\3\2\2\2\u038f\u0390\3\2\2\2\u0390S\3\2\2\2\u0391") + buf.write("\u0392\7\62\2\2\u0392\u0393\7\b\2\2\u0393\u0394\7\u00ec") + buf.write("\2\2\u0394\u0395\7\30\2\2\u0395\u0396\7\u00fa\2\2\u0396") + buf.write("\u0397\7\31\2\2\u0397\u0398\7!\2\2\u0398\u0399\7=\2\2") + buf.write("\u0399\u039a\7\b\2\2\u039a\u039b\7\u00ec\2\2\u039b\u039c") + buf.write("\7\30\2\2\u039c\u039d\7\u00fa\2\2\u039d\u039e\7\31\2\2") + buf.write("\u039eU\3\2\2\2\u039f\u03a8\7~\2\2\u03a0\u03a8\7y\2\2") + buf.write("\u03a1\u03a8\7{\2\2\u03a2\u03a8\7\u0080\2\2\u03a3\u03a8") + buf.write("\7|\2\2\u03a4\u03a8\7\177\2\2\u03a5\u03a8\7z\2\2\u03a6") + buf.write("\u03a8\7}\2\2\u03a7\u039f\3\2\2\2\u03a7\u03a0\3\2\2\2") + buf.write("\u03a7\u03a1\3\2\2\2\u03a7\u03a2\3\2\2\2\u03a7\u03a3\3") + buf.write("\2\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6") + buf.write("\3\2\2\2\u03a8W\3\2\2\2\u03a9\u03aa\7\u00fb\2\2\u03aa") + buf.write("\u03ab\7\32\2\2\u03ab\u03ac\7\u00fa\2\2\u03ac\u03b6\7") + buf.write("\33\2\2\u03ad\u03b2\7\u00fb\2\2\u03ae\u03af\7\34\2\2\u03af") + buf.write("\u03b1\5\u015c\u00af\2\u03b0\u03ae\3\2\2\2\u03b1\u03b4") + buf.write("\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3") + buf.write("\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5\u03a9\3\2\2\2") + buf.write("\u03b5\u03ad\3\2\2\2\u03b6Y\3\2\2\2\u03b7\u03b9\7\35\2") + buf.write("\2\u03b8\u03b7\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba") + buf.write("\3\2\2\2\u03ba\u03e4\7\u00fa\2\2\u03bb\u03e4\7\u00d3\2") + buf.write("\2\u03bc\u03e4\7\u00d4\2\2\u03bd\u03e4\7\u00d5\2\2\u03be") + buf.write("\u03e4\7\u00d6\2\2\u03bf\u03e4\7\u00d7\2\2\u03c0\u03c1") + buf.write("\7\u00fa\2\2\u03c1\u03c2\7\36\2\2\u03c2\u03c3\7\u00fa") + buf.write("\2\2\u03c3\u03c4\7\36\2\2\u03c4\u03e4\7\u00fa\2\2\u03c5") + buf.write("\u03c6\7\u00fa\2\2\u03c6\u03c7\7\37\2\2\u03c7\u03c8\7") + buf.write("\u00fa\2\2\u03c8\u03c9\7\37\2\2\u03c9\u03e4\7\u00fa\2") + buf.write("\2\u03ca\u03cb\7\u00fa\2\2\u03cb\u03cc\7 \2\2\u03cc\u03cd") + buf.write("\7\u00fa\2\2\u03cd\u03ce\7 \2\2\u03ce\u03cf\5L\'\2\u03cf") + buf.write("\u03d0\7 \2\2\u03d0\u03d1\7\u00ec\2\2\u03d1\u03d2\7\30") + buf.write("\2\2\u03d2\u03d3\7\u00fa\2\2\u03d3\u03d4\7\31\2\2\u03d4") + buf.write("\u03e4\3\2\2\2\u03d5\u03d6\7\u00ec\2\2\u03d6\u03d7\7\30") + buf.write("\2\2\u03d7\u03d8\7\u00fa\2\2\u03d8\u03e4\7\31\2\2\u03d9") + buf.write("\u03da\7\26\2\2\u03da\u03df\7\u00fa\2\2\u03db\u03dc\7") + buf.write("!\2\2\u03dc\u03de\7\u00fa\2\2\u03dd\u03db\3\2\2\2\u03de") + buf.write("\u03e1\3\2\2\2\u03df\u03dd\3\2\2\2\u03df\u03e0\3\2\2\2") + buf.write("\u03e0\u03e2\3\2\2\2\u03e1\u03df\3\2\2\2\u03e2\u03e4\7") + buf.write("\27\2\2\u03e3\u03b8\3\2\2\2\u03e3\u03bb\3\2\2\2\u03e3") + buf.write("\u03bc\3\2\2\2\u03e3\u03bd\3\2\2\2\u03e3\u03be\3\2\2\2") + buf.write("\u03e3\u03bf\3\2\2\2\u03e3\u03c0\3\2\2\2\u03e3\u03c5\3") + buf.write("\2\2\2\u03e3\u03ca\3\2\2\2\u03e3\u03d5\3\2\2\2\u03e3\u03d9") + buf.write("\3\2\2\2\u03e4[\3\2\2\2\u03e5\u03e6\7\u0092\2\2\u03e6") + buf.write("\u03e7\7\b\2\2\u03e7\u03e8\7\t\2\2\u03e8\u03e9\7\30\2") + buf.write("\2\u03e9\u03ea\7\u00fa\2\2\u03ea\u03eb\7\31\2\2\u03eb") + buf.write("]\3\2\2\2\u03ec\u03ed\7\u0093\2\2\u03ed_\3\2\2\2\u03ee") + buf.write("\u03f1\5\\/\2\u03ef\u03f1\5^\60\2\u03f0\u03ee\3\2\2\2") + buf.write("\u03f0\u03ef\3\2\2\2\u03f1a\3\2\2\2\u03f2\u03f7\5`\61") + buf.write("\2\u03f3\u03f4\7!\2\2\u03f4\u03f6\5`\61\2\u03f5\u03f3") + buf.write("\3\2\2\2\u03f6\u03f9\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7") + buf.write("\u03f8\3\2\2\2\u03f8c\3\2\2\2\u03f9\u03f7\3\2\2\2\u03fa") + buf.write("\u03fb\7\67\2\2\u03fb\u03fc\7/\2\2\u03fc\u03fd\7\b\2\2") + buf.write("\u03fd\u03fe\7\u00fa\2\2\u03fe\u03ff\7!\2\2\u03ff\u0400") + buf.write("\7.\2\2\u0400\u0401\7\b\2\2\u0401\u0402\7\u00ec\2\2\u0402") + buf.write("\u0403\7\30\2\2\u0403\u0404\7\u00fa\2\2\u0404\u0405\7") + buf.write("\31\2\2\u0405\u0409\7 \2\2\u0406\u0408\5f\64\2\u0407\u0406") + buf.write("\3\2\2\2\u0408\u040b\3\2\2\2\u0409\u0407\3\2\2\2\u0409") + buf.write("\u040a\3\2\2\2\u040a\u040c\3\2\2\2\u040b\u0409\3\2\2\2") + buf.write("\u040c\u040d\7\66\2\2\u040d\u040e\7 \2\2\u040ee\3\2\2") + buf.write("\2\u040f\u041f\5j\66\2\u0410\u041f\5l\67\2\u0411\u041f") + buf.write("\5n8\2\u0412\u041f\5\u00a4S\2\u0413\u041f\5p9\2\u0414") + buf.write("\u041f\5\u0088E\2\u0415\u041f\5\u00f8}\2\u0416\u041f\5") + buf.write("\u0118\u008d\2\u0417\u041f\5\u011a\u008e\2\u0418\u041f") + buf.write("\5\u0110\u0089\2\u0419\u041f\5\u011c\u008f\2\u041a\u041f") + buf.write("\5\u0120\u0091\2\u041b\u041c\5\u0096L\2\u041c\u041d\7") + buf.write(" \2\2\u041d\u041f\3\2\2\2\u041e\u040f\3\2\2\2\u041e\u0410") + buf.write("\3\2\2\2\u041e\u0411\3\2\2\2\u041e\u0412\3\2\2\2\u041e") + buf.write("\u0413\3\2\2\2\u041e\u0414\3\2\2\2\u041e\u0415\3\2\2\2") + buf.write("\u041e\u0416\3\2\2\2\u041e\u0417\3\2\2\2\u041e\u0418\3") + buf.write("\2\2\2\u041e\u0419\3\2\2\2\u041e\u041a\3\2\2\2\u041e\u041b") + buf.write("\3\2\2\2\u041fg\3\2\2\2\u0420\u0421\78\2\2\u0421\u0422") + buf.write("\7/\2\2\u0422\u0423\7\b\2\2\u0423\u0424\7\u00fa\2\2\u0424") + buf.write("\u0433\7!\2\2\u0425\u0426\79\2\2\u0426\u0427\7\b\2\2\u0427") + buf.write("\u0428\7\u00ec\2\2\u0428\u0429\7\30\2\2\u0429\u042a\7") + buf.write("\u00fa\2\2\u042a\u042b\7\31\2\2\u042b\u042c\7 \2\2\u042c") + buf.write("\u042d\7:\2\2\u042d\u042e\7\b\2\2\u042e\u042f\5L\'\2\u042f") + buf.write("\u0430\7 \2\2\u0430\u0432\3\2\2\2\u0431\u0425\3\2\2\2") + buf.write("\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3") + buf.write("\2\2\2\u0434\u0439\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438") + buf.write("\5f\64\2\u0437\u0436\3\2\2\2\u0438\u043b\3\2\2\2\u0439") + buf.write("\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043c\3\2\2\2") + buf.write("\u043b\u0439\3\2\2\2\u043c\u043d\7\66\2\2\u043d\u043e") + buf.write("\7 \2\2\u043ei\3\2\2\2\u043f\u0440\5\\/\2\u0440\u0441") + buf.write("\7 \2\2\u0441k\3\2\2\2\u0442\u0443\5^\60\2\u0443\u0444") + buf.write("\7 \2\2\u0444m\3\2\2\2\u0445\u0446\7\u0094\2\2\u0446\u0447") + buf.write("\7\u00fb\2\2\u0447\u0448\7!\2\2\u0448\u0449\5\u0124\u0093") + buf.write("\2\u0449\u044a\7\u0095\2\2\u044a\u044b\7 \2\2\u044bo\3") + buf.write("\2\2\2\u044c\u0450\5r:\2\u044d\u0450\5z>\2\u044e\u0450") + buf.write("\5~@\2\u044f\u044c\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u044e") + buf.write("\3\2\2\2\u0450q\3\2\2\2\u0451\u0452\7;\2\2\u0452\u0453") + buf.write("\7>\2\2\u0453\u0454\7\b\2\2\u0454\u0455\7\u00ec\2\2\u0455") + buf.write("\u0456\7\30\2\2\u0456\u0457\7\u00fa\2\2\u0457\u045c\7") + buf.write("\31\2\2\u0458\u0459\7!\2\2\u0459\u045a\7@\2\2\u045a\u045b") + buf.write("\7\b\2\2\u045b\u045d\5v<\2\u045c\u0458\3\2\2\2\u045c\u045d") + buf.write("\3\2\2\2\u045d\u0472\3\2\2\2\u045e\u045f\7!\2\2\u045f") + buf.write("\u0461\5b\62\2\u0460\u045e\3\2\2\2\u0460\u0461\3\2\2\2") + buf.write("\u0461\u0462\3\2\2\2\u0462\u0473\7 \2\2\u0463\u0464\7") + buf.write("!\2\2\u0464\u0466\5b\62\2\u0465\u0463\3\2\2\2\u0465\u0466") + buf.write("\3\2\2\2\u0466\u046e\3\2\2\2\u0467\u046b\7!\2\2\u0468") + buf.write("\u046a\5t;\2\u0469\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b") + buf.write("\u0469\3\2\2\2\u046b\u046c\3\2\2\2\u046c\u046f\3\2\2\2") + buf.write("\u046d\u046b\3\2\2\2\u046e\u0467\3\2\2\2\u046e\u046f\3") + buf.write("\2\2\2\u046f\u0470\3\2\2\2\u0470\u0471\7<\2\2\u0471\u0473") + buf.write("\7 \2\2\u0472\u0460\3\2\2\2\u0472\u0465\3\2\2\2\u0473") + buf.write("s\3\2\2\2\u0474\u0477\5p9\2\u0475\u0477\5\u0088E\2\u0476") + buf.write("\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477u\3\2\2\2\u0478") + buf.write("\u047d\5x=\2\u0479\u047a\7(\2\2\u047a\u047c\5x=\2\u047b") + buf.write("\u0479\3\2\2\2\u047c\u047f\3\2\2\2\u047d\u047b\3\2\2\2") + buf.write("\u047d\u047e\3\2\2\2\u047ew\3\2\2\2\u047f\u047d\3\2\2") + buf.write("\2\u0480\u0481\t\5\2\2\u0481y\3\2\2\2\u0482\u0483\7>\2") + buf.write("\2\u0483\u0484\7=\2\2\u0484\u0485\7\b\2\2\u0485\u0486") + buf.write("\7\u00ec\2\2\u0486\u0487\7\30\2\2\u0487\u0488\7\u00fa") + buf.write("\2\2\u0488\u0489\7\31\2\2\u0489\u048a\7!\2\2\u048a\u048b") + buf.write("\7>\2\2\u048b\u048c\7\b\2\2\u048c\u048d\7\u00ec\2\2\u048d") + buf.write("\u048e\7\30\2\2\u048e\u048f\7\u00fa\2\2\u048f\u0497\7") + buf.write("\31\2\2\u0490\u0491\7!\2\2\u0491\u0492\7>\2\2\u0492\u0493") + buf.write("\7\b\2\2\u0493\u0494\7\u00ec\2\2\u0494\u0495\7\30\2\2") + buf.write("\u0495\u0496\7\u00fa\2\2\u0496\u0498\7\31\2\2\u0497\u0490") + buf.write("\3\2\2\2\u0497\u0498\3\2\2\2\u0498\u04a9\3\2\2\2\u0499") + buf.write("\u049a\7!\2\2\u049a\u049b\7@\2\2\u049b\u049c\7\b\2\2\u049c") + buf.write("\u04a1\5|?\2\u049d\u049e\7(\2\2\u049e\u04a0\5|?\2\u049f") + buf.write("\u049d\3\2\2\2\u04a0\u04a3\3\2\2\2\u04a1\u049f\3\2\2\2") + buf.write("\u04a1\u04a2\3\2\2\2\u04a2\u04a4\3\2\2\2\u04a3\u04a1\3") + buf.write("\2\2\2\u04a4\u04a5\7!\2\2\u04a5\u04a6\7t\2\2\u04a6\u04a7") + buf.write("\7\b\2\2\u04a7\u04a8\7\u00fa\2\2\u04a8\u04aa\3\2\2\2\u04a9") + buf.write("\u0499\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ad\3\2\2\2") + buf.write("\u04ab\u04ac\7!\2\2\u04ac\u04ae\5b\62\2\u04ad\u04ab\3") + buf.write("\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04af\3\2\2\2\u04af\u04b0") + buf.write("\7 \2\2\u04b0{\3\2\2\2\u04b1\u04b4\7\u00fa\2\2\u04b2\u04b4") + buf.write("\5V,\2\u04b3\u04b1\3\2\2\2\u04b3\u04b2\3\2\2\2\u04b4}") + buf.write("\3\2\2\2\u04b5\u04b8\5\u0080A\2\u04b6\u04b8\5\u0086D\2") + buf.write("\u04b7\u04b5\3\2\2\2\u04b7\u04b6\3\2\2\2\u04b8\177\3\2") + buf.write("\2\2\u04b9\u04e9\7n\2\2\u04ba\u04bb\7*\2\2\u04bb\u04bc") + buf.write("\7\b\2\2\u04bc\u04bd\7\u00ec\2\2\u04bd\u04be\7\30\2\2") + buf.write("\u04be\u04bf\7\u00fa\2\2\u04bf\u04c0\7\31\2\2\u04c0\u04c1") + buf.write("\7!\2\2\u04c1\u04c2\7o\2\2\u04c2\u04c3\7\b\2\2\u04c3\u04c4") + buf.write("\5L\'\2\u04c4\u04c5\7!\2\2\u04c5\u04c6\7/\2\2\u04c6\u04c7") + buf.write("\7\b\2\2\u04c7\u04c8\7\u00fa\2\2\u04c8\u04c9\7!\2\2\u04c9") + buf.write("\u04ca\7\u0090\2\2\u04ca\u04cb\7\b\2\2\u04cb\u04cc\7\u00fa") + buf.write("\2\2\u04cc\u04cd\7!\2\2\u04cd\u04ea\3\2\2\2\u04ce\u04cf") + buf.write("\7o\2\2\u04cf\u04d0\7\b\2\2\u04d0\u04d1\5L\'\2\u04d1\u04d2") + buf.write("\7!\2\2\u04d2\u04d3\7/\2\2\u04d3\u04d4\7\b\2\2\u04d4\u04d5") + buf.write("\7\u00fa\2\2\u04d5\u04d6\7!\2\2\u04d6\u04d7\7\u0090\2") + buf.write("\2\u04d7\u04d8\7\b\2\2\u04d8\u04d9\7\u00fa\2\2\u04d9\u04da") + buf.write("\7!\2\2\u04da\u04ea\3\2\2\2\u04db\u04dc\7/\2\2\u04dc\u04dd") + buf.write("\7\b\2\2\u04dd\u04de\7\u00fa\2\2\u04de\u04df\7!\2\2\u04df") + buf.write("\u04e0\7\u0090\2\2\u04e0\u04e5\7\b\2\2\u04e1\u04e2\7\u00fb") + buf.write("\2\2\u04e2\u04e6\7!\2\2\u04e3\u04e4\7\u00fa\2\2\u04e4") + buf.write("\u04e6\7!\2\2\u04e5\u04e1\3\2\2\2\u04e5\u04e3\3\2\2\2") + buf.write("\u04e6\u04ea\3\2\2\2\u04e7\u04e8\7\u00fa\2\2\u04e8\u04ea") + buf.write("\7!\2\2\u04e9\u04ba\3\2\2\2\u04e9\u04ce\3\2\2\2\u04e9") + buf.write("\u04db\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04ea\3\2\2\2") + buf.write("\u04ea\u04eb\3\2\2\2\u04eb\u04f0\5P)\2\u04ec\u04ed\7!") + buf.write("\2\2\u04ed\u04ee\7@\2\2\u04ee\u04ef\7\b\2\2\u04ef\u04f1") + buf.write("\5\u0082B\2\u04f0\u04ec\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1") + buf.write("\u04f6\3\2\2\2\u04f2\u04f3\7!\2\2\u04f3\u04f4\7t\2\2\u04f4") + buf.write("\u04f5\7\b\2\2\u04f5\u04f7\7\u00fa\2\2\u04f6\u04f2\3\2") + buf.write("\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04fa\3\2\2\2\u04f8\u04f9") + buf.write("\7!\2\2\u04f9\u04fb\5\u00b4[\2\u04fa\u04f8\3\2\2\2\u04fa") + buf.write("\u04fb\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fd\7 \2\2") + buf.write("\u04fd\u0081\3\2\2\2\u04fe\u0503\5\u0084C\2\u04ff\u0500") + buf.write("\7(\2\2\u0500\u0502\5\u0084C\2\u0501\u04ff\3\2\2\2\u0502") + buf.write("\u0505\3\2\2\2\u0503\u0501\3\2\2\2\u0503\u0504\3\2\2\2") + buf.write("\u0504\u0083\3\2\2\2\u0505\u0503\3\2\2\2\u0506\u0509\7") + buf.write("\u00fa\2\2\u0507\u0509\5V,\2\u0508\u0506\3\2\2\2\u0508") + buf.write("\u0507\3\2\2\2\u0509\u0085\3\2\2\2\u050a\u050b\7\u0099") + buf.write("\2\2\u050b\u050c\7\u009b\2\2\u050c\u050d\7\b\2\2\u050d") + buf.write("\u050e\7\u00fb\2\2\u050e\u050f\7!\2\2\u050f\u0510\5T+") + buf.write("\2\u0510\u0514\7!\2\2\u0511\u0512\5b\62\2\u0512\u0513") + buf.write("\7!\2\2\u0513\u0515\3\2\2\2\u0514\u0511\3\2\2\2\u0514") + buf.write("\u0515\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0517\7\u009a") + buf.write("\2\2\u0517\u0518\7 \2\2\u0518\u0087\3\2\2\2\u0519\u0520") + buf.write("\5\u00b8]\2\u051a\u0520\5\u00e8u\2\u051b\u0520\5\u00c6") + buf.write("d\2\u051c\u0520\5\u00d4k\2\u051d\u0520\5\u00e2r\2\u051e") + buf.write("\u0520\5\u00f0y\2\u051f\u0519\3\2\2\2\u051f\u051a\3\2") + buf.write("\2\2\u051f\u051b\3\2\2\2\u051f\u051c\3\2\2\2\u051f\u051d") + buf.write("\3\2\2\2\u051f\u051e\3\2\2\2\u0520\u0089\3\2\2\2\u0521") + buf.write("\u0522\5`\61\2\u0522\u0523\7!\2\2\u0523\u052d\3\2\2\2") + buf.write("\u0524\u052d\5\u008cG\2\u0525\u052d\5\u008eH\2\u0526\u052d") + buf.write("\5\u0090I\2\u0527\u052d\5\u0092J\2\u0528\u052d\5\u0094") + buf.write("K\2\u0529\u052d\5\u011c\u008f\2\u052a\u052d\5\u0096L\2") + buf.write("\u052b\u052d\5\u0098M\2\u052c\u0521\3\2\2\2\u052c\u0524") + buf.write("\3\2\2\2\u052c\u0525\3\2\2\2\u052c\u0526\3\2\2\2\u052c") + buf.write("\u0527\3\2\2\2\u052c\u0528\3\2\2\2\u052c\u0529\3\2\2\2") + buf.write("\u052c\u052a\3\2\2\2\u052c\u052b\3\2\2\2\u052d\u008b\3") + buf.write("\2\2\2\u052e\u052f\7p\2\2\u052f\u0530\7\62\2\2\u0530\u0531") + buf.write("\7\b\2\2\u0531\u0532\7\u00ec\2\2\u0532\u0533\7\30\2\2") + buf.write("\u0533\u0534\7\u00fa\2\2\u0534\u0535\7\31\2\2\u0535\u0542") + buf.write("\7!\2\2\u0536\u0537\7@\2\2\u0537\u0538\7\b\2\2\u0538\u053d") + buf.write("\5\u009eP\2\u0539\u053a\7(\2\2\u053a\u053c\5\u009eP\2") + buf.write("\u053b\u0539\3\2\2\2\u053c\u053f\3\2\2\2\u053d\u053b\3") + buf.write("\2\2\2\u053d\u053e\3\2\2\2\u053e\u0540\3\2\2\2\u053f\u053d") + buf.write("\3\2\2\2\u0540\u0541\7!\2\2\u0541\u0543\3\2\2\2\u0542") + buf.write("\u0536\3\2\2\2\u0542\u0543\3\2\2\2\u0543\u0544\3\2\2\2") + buf.write("\u0544\u0545\5\u0124\u0093\2\u0545\u0547\7s\2\2\u0546") + buf.write("\u0548\7 \2\2\u0547\u0546\3\2\2\2\u0547\u0548\3\2\2\2") + buf.write("\u0548\u008d\3\2\2\2\u0549\u054a\7r\2\2\u054a\u054b\7") + buf.write("\62\2\2\u054b\u054c\7\b\2\2\u054c\u054d\7\u00ec\2\2\u054d") + buf.write("\u054e\7\30\2\2\u054e\u054f\7\u00fa\2\2\u054f\u0550\7") + buf.write("\31\2\2\u0550\u055d\7!\2\2\u0551\u0552\7@\2\2\u0552\u0553") + buf.write("\7\b\2\2\u0553\u0558\5\u009eP\2\u0554\u0555\7(\2\2\u0555") + buf.write("\u0557\5\u009eP\2\u0556\u0554\3\2\2\2\u0557\u055a\3\2") + buf.write("\2\2\u0558\u0556\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u055b") + buf.write("\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7!\2\2\u055c") + buf.write("\u055e\3\2\2\2\u055d\u0551\3\2\2\2\u055d\u055e\3\2\2\2") + buf.write("\u055e\u055f\3\2\2\2\u055f\u0560\5\u0124\u0093\2\u0560") + buf.write("\u0562\7s\2\2\u0561\u0563\7 \2\2\u0562\u0561\3\2\2\2\u0562") + buf.write("\u0563\3\2\2\2\u0563\u008f\3\2\2\2\u0564\u0565\7l\2\2") + buf.write("\u0565\u0566\5\u0124\u0093\2\u0566\u0567\7 \2\2\u0567") + buf.write("\u0568\5\u00b4[\2\u0568\u056a\7s\2\2\u0569\u056b\7 \2") + buf.write("\2\u056a\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u0091") + buf.write("\3\2\2\2\u056c\u056d\7\u00a4\2\2\u056d\u056e\7\u00a5\2") + buf.write("\2\u056e\u056f\7\b\2\2\u056f\u0570\7\u00fa\2\2\u0570\u0093") + buf.write("\3\2\2\2\u0571\u0572\7\u00a6\2\2\u0572\u0573\7\b\2\2\u0573") + buf.write("\u0574\7\u00ec\2\2\u0574\u0575\7\30\2\2\u0575\u0576\7") + buf.write("\u00fa\2\2\u0576\u0577\7\31\2\2\u0577\u0578\7!\2\2\u0578") + buf.write("\u0095\3\2\2\2\u0579\u057a\7\u00eb\2\2\u057a\u057b\7\b") + buf.write("\2\2\u057b\u057c\5L\'\2\u057c\u057d\7!\2\2\u057d\u0097") + buf.write("\3\2\2\2\u057e\u057f\7q\2\2\u057f\u0580\7\62\2\2\u0580") + buf.write("\u0581\7\b\2\2\u0581\u0582\7\u00ec\2\2\u0582\u0583\7\30") + buf.write("\2\2\u0583\u0584\7\u00fa\2\2\u0584\u0585\7\31\2\2\u0585") + buf.write("\u058a\7!\2\2\u0586\u0587\7M\2\2\u0587\u0588\7\b\2\2\u0588") + buf.write("\u0589\7\u00fa\2\2\u0589\u058b\7!\2\2\u058a\u0586\3\2") + buf.write("\2\2\u058a\u058b\3\2\2\2\u058b\u058c\3\2\2\2\u058c\u058d") + buf.write("\5\u0124\u0093\2\u058d\u058f\7s\2\2\u058e\u0590\7 \2\2") + buf.write("\u058f\u058e\3\2\2\2\u058f\u0590\3\2\2\2\u0590\u0099\3") + buf.write("\2\2\2\u0591\u0593\5\u008aF\2\u0592\u0591\3\2\2\2\u0593") + buf.write("\u0596\3\2\2\2\u0594\u0592\3\2\2\2\u0594\u0595\3\2\2\2") + buf.write("\u0595\u009b\3\2\2\2\u0596\u0594\3\2\2\2\u0597\u059f\5") + buf.write("\u00a0Q\2\u0598\u059f\5\u00a2R\2\u0599\u059f\5\u00a6T") + buf.write("\2\u059a\u059f\5\u00a4S\2\u059b\u059f\5\u00a8U\2\u059c") + buf.write("\u059f\5\u00b0Y\2\u059d\u059f\5\u00b2Z\2\u059e\u0597\3") + buf.write("\2\2\2\u059e\u0598\3\2\2\2\u059e\u0599\3\2\2\2\u059e\u059a") + buf.write("\3\2\2\2\u059e\u059b\3\2\2\2\u059e\u059c\3\2\2\2\u059e") + buf.write("\u059d\3\2\2\2\u059f\u009d\3\2\2\2\u05a0\u05a9\7\u00fa") + buf.write("\2\2\u05a1\u05a9\7y\2\2\u05a2\u05a9\7v\2\2\u05a3\u05a9") + buf.write("\7u\2\2\u05a4\u05a9\7{\2\2\u05a5\u05a9\7|\2\2\u05a6\u05a9") + buf.write("\7z\2\2\u05a7\u05a9\7}\2\2\u05a8\u05a0\3\2\2\2\u05a8\u05a1") + buf.write("\3\2\2\2\u05a8\u05a2\3\2\2\2\u05a8\u05a3\3\2\2\2\u05a8") + buf.write("\u05a4\3\2\2\2\u05a8\u05a5\3\2\2\2\u05a8\u05a6\3\2\2\2") + buf.write("\u05a8\u05a7\3\2\2\2\u05a9\u009f\3\2\2\2\u05aa\u05ab\7") + buf.write("k\2\2\u05ab\u05ac\5\u0124\u0093\2\u05ac\u05b9\7 \2\2\u05ad") + buf.write("\u05ae\7@\2\2\u05ae\u05af\7\b\2\2\u05af\u05b4\5\u009e") + buf.write("P\2\u05b0\u05b1\7(\2\2\u05b1\u05b3\5\u009eP\2\u05b2\u05b0") + buf.write("\3\2\2\2\u05b3\u05b6\3\2\2\2\u05b4\u05b2\3\2\2\2\u05b4") + buf.write("\u05b5\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6\u05b4\3\2\2\2") + buf.write("\u05b7\u05b8\7!\2\2\u05b8\u05ba\3\2\2\2\u05b9\u05ad\3") + buf.write("\2\2\2\u05b9\u05ba\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc") + buf.write("\5\u00b4[\2\u05bc\u05be\7s\2\2\u05bd\u05bf\7 \2\2\u05be") + buf.write("\u05bd\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u00a1\3\2\2\2") + buf.write("\u05c0\u05c1\7K\2\2\u05c1\u05c2\5\u0124\u0093\2\u05c2") + buf.write("\u05cf\7 \2\2\u05c3\u05c4\7@\2\2\u05c4\u05c5\7\b\2\2\u05c5") + buf.write("\u05ca\5\u009eP\2\u05c6\u05c7\7(\2\2\u05c7\u05c9\5\u009e") + buf.write("P\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3\2\2\2\u05ca\u05c8") + buf.write("\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cd\3\2\2\2\u05cc") + buf.write("\u05ca\3\2\2\2\u05cd\u05ce\7!\2\2\u05ce\u05d0\3\2\2\2") + buf.write("\u05cf\u05c3\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05d1\3") + buf.write("\2\2\2\u05d1\u05d2\5\u00b4[\2\u05d2\u05d4\7s\2\2\u05d3") + buf.write("\u05d5\7 \2\2\u05d4\u05d3\3\2\2\2\u05d4\u05d5\3\2\2\2") + buf.write("\u05d5\u00a3\3\2\2\2\u05d6\u05de\7c\2\2\u05d7\u05d8\5") + buf.write("\u00a6T\2\u05d8\u05d9\7!\2\2\u05d9\u05df\3\2\2\2\u05da") + buf.write("\u05db\7\b\2\2\u05db\u05dc\5Z.\2\u05dc\u05dd\7!\2\2\u05dd") + buf.write("\u05df\3\2\2\2\u05de\u05d7\3\2\2\2\u05de\u05da\3\2\2\2") + buf.write("\u05df\u05e4\3\2\2\2\u05e0\u05e1\7\u009b\2\2\u05e1\u05e2") + buf.write("\7\b\2\2\u05e2\u05e3\7\u00fb\2\2\u05e3\u05e5\7!\2\2\u05e4") + buf.write("\u05e0\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u00a5\3\2\2\2") + buf.write("\u05e6\u05e7\7\u0096\2\2\u05e7\u05e8\7\b\2\2\u05e8\u05e9") + buf.write("\5\u0124\u0093\2\u05e9\u00a7\3\2\2\2\u05ea\u05eb\5\u00aa") + buf.write("V\2\u05eb\u00a9\3\2\2\2\u05ec\u05ed\7?\2\2\u05ed\u05ee") + buf.write("\7>\2\2\u05ee\u05ef\7\b\2\2\u05ef\u05f0\7\u00ec\2\2\u05f0") + buf.write("\u05f1\7\30\2\2\u05f1\u05f2\7\u00fa\2\2\u05f2\u05f3\7") + buf.write("\31\2\2\u05f3\u05f4\7!\2\2\u05f4\u05f5\7\u0096\2\2\u05f5") + buf.write("\u05f6\7\b\2\2\u05f6\u05f7\5Z.\2\u05f7\u05f8\7!\2\2\u05f8") + buf.write("\u05f9\7@\2\2\u05f9\u05fa\7\b\2\2\u05fa\u05ff\5\u00ac") + buf.write("W\2\u05fb\u05fc\7!\2\2\u05fc\u05fd\7t\2\2\u05fd\u05fe") + buf.write("\7\b\2\2\u05fe\u0600\7\u00fa\2\2\u05ff\u05fb\3\2\2\2\u05ff") + buf.write("\u0600\3\2\2\2\u0600\u0605\3\2\2\2\u0601\u0602\7!\2\2") + buf.write("\u0602\u0604\5\\/\2\u0603\u0601\3\2\2\2\u0604\u0607\3") + buf.write("\2\2\2\u0605\u0603\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0608") + buf.write("\3\2\2\2\u0607\u0605\3\2\2\2\u0608\u0609\7 \2\2\u0609") + buf.write("\u00ab\3\2\2\2\u060a\u060f\5\u00aeX\2\u060b\u060c\7(\2") + buf.write("\2\u060c\u060e\5\u00aeX\2\u060d\u060b\3\2\2\2\u060e\u0611") + buf.write("\3\2\2\2\u060f\u060d\3\2\2\2\u060f\u0610\3\2\2\2\u0610") + buf.write("\u00ad\3\2\2\2\u0611\u060f\3\2\2\2\u0612\u061e\7\u00fa") + buf.write("\2\2\u0613\u061e\7\u00ed\2\2\u0614\u061e\7\u00ee\2\2\u0615") + buf.write("\u061e\7y\2\2\u0616\u061e\7{\2\2\u0617\u061e\7\u0080\2") + buf.write("\2\u0618\u061e\7|\2\2\u0619\u061e\7v\2\2\u061a\u061e\7") + buf.write("u\2\2\u061b\u061e\7z\2\2\u061c\u061e\7}\2\2\u061d\u0612") + buf.write("\3\2\2\2\u061d\u0613\3\2\2\2\u061d\u0614\3\2\2\2\u061d") + buf.write("\u0615\3\2\2\2\u061d\u0616\3\2\2\2\u061d\u0617\3\2\2\2") + buf.write("\u061d\u0618\3\2\2\2\u061d\u0619\3\2\2\2\u061d\u061a\3") + buf.write("\2\2\2\u061d\u061b\3\2\2\2\u061d\u061c\3\2\2\2\u061e\u00af") + buf.write("\3\2\2\2\u061f\u0620\7\u0097\2\2\u0620\u0621\5\u0124\u0093") + buf.write("\2\u0621\u0622\7 \2\2\u0622\u00b1\3\2\2\2\u0623\u0624") + buf.write("\7\u0098\2\2\u0624\u0625\5\u0124\u0093\2\u0625\u0626\7") + buf.write(" \2\2\u0626\u00b3\3\2\2\2\u0627\u0629\5\u00b6\\\2\u0628") + buf.write("\u0627\3\2\2\2\u0629\u062c\3\2\2\2\u062a\u0628\3\2\2\2") + buf.write("\u062a\u062b\3\2\2\2\u062b\u00b5\3\2\2\2\u062c\u062a\3") + buf.write("\2\2\2\u062d\u0630\5\u008aF\2\u062e\u0630\5\u009cO\2\u062f") + buf.write("\u062d\3\2\2\2\u062f\u062e\3\2\2\2\u0630\u00b7\3\2\2\2") + buf.write("\u0631\u0634\5\u00ba^\2\u0632\u0634\5\u00c0a\2\u0633\u0631") + buf.write("\3\2\2\2\u0633\u0632\3\2\2\2\u0634\u00b9\3\2\2\2\u0635") + buf.write("\u0636\7\\\2\2\u0636\u0637\5R*\2\u0637\u0638\5T+\2\u0638") + buf.write("\u063e\7!\2\2\u0639\u063a\7@\2\2\u063a\u063b\7\b\2\2\u063b") + buf.write("\u063c\5\u00bc_\2\u063c\u063d\7!\2\2\u063d\u063f\3\2\2") + buf.write("\2\u063e\u0639\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0644") + buf.write("\3\2\2\2\u0640\u0641\7t\2\2\u0641\u0642\7\b\2\2\u0642") + buf.write("\u0643\7\u00fa\2\2\u0643\u0645\7!\2\2\u0644\u0640\3\2") + buf.write("\2\2\u0644\u0645\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0647") + buf.write("\5\u00b4[\2\u0647\u0648\7]\2\2\u0648\u0649\7 \2\2\u0649") + buf.write("\u00bb\3\2\2\2\u064a\u064f\5\u00be`\2\u064b\u064c\7(\2") + buf.write("\2\u064c\u064e\5\u00be`\2\u064d\u064b\3\2\2\2\u064e\u0651") + buf.write("\3\2\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650") + buf.write("\u00bd\3\2\2\2\u0651\u064f\3\2\2\2\u0652\u0659\7\u00fa") + buf.write("\2\2\u0653\u0659\7u\2\2\u0654\u0659\7v\2\2\u0655\u0659") + buf.write("\7w\2\2\u0656\u0659\7x\2\2\u0657\u0659\5V,\2\u0658\u0652") + buf.write("\3\2\2\2\u0658\u0653\3\2\2\2\u0658\u0654\3\2\2\2\u0658") + buf.write("\u0655\3\2\2\2\u0658\u0656\3\2\2\2\u0658\u0657\3\2\2\2") + buf.write("\u0659\u00bf\3\2\2\2\u065a\u065b\7\u00a1\2\2\u065b\u065c") + buf.write("\5P)\2\u065c\u0662\7!\2\2\u065d\u065e\7@\2\2\u065e\u065f") + buf.write("\7\b\2\2\u065f\u0660\5\u00c2b\2\u0660\u0661\7!\2\2\u0661") + buf.write("\u0663\3\2\2\2\u0662\u065d\3\2\2\2\u0662\u0663\3\2\2\2") + buf.write("\u0663\u0664\3\2\2\2\u0664\u0665\7\u00a2\2\2\u0665\u0666") + buf.write("\7\b\2\2\u0666\u0667\7\u00ec\2\2\u0667\u0668\7\30\2\2") + buf.write("\u0668\u0669\7\u00fa\2\2\u0669\u066a\7\31\2\2\u066a\u066b") + buf.write("\7!\2\2\u066b\u066c\5\u009aN\2\u066c\u066d\7\u00a3\2\2") + buf.write("\u066d\u066e\7 \2\2\u066e\u00c1\3\2\2\2\u066f\u0674\5") + buf.write("\u00c4c\2\u0670\u0671\7(\2\2\u0671\u0673\5\u00c4c\2\u0672") + buf.write("\u0670\3\2\2\2\u0673\u0676\3\2\2\2\u0674\u0672\3\2\2\2") + buf.write("\u0674\u0675\3\2\2\2\u0675\u00c3\3\2\2\2\u0676\u0674\3") + buf.write("\2\2\2\u0677\u067a\7\u00fa\2\2\u0678\u067a\5V,\2\u0679") + buf.write("\u0677\3\2\2\2\u0679\u0678\3\2\2\2\u067a\u00c5\3\2\2\2") + buf.write("\u067b\u067e\5\u00c8e\2\u067c\u067e\5\u00d0i\2\u067d\u067b") + buf.write("\3\2\2\2\u067d\u067c\3\2\2\2\u067e\u00c7\3\2\2\2\u067f") + buf.write("\u0680\7^\2\2\u0680\u0681\5R*\2\u0681\u0682\5T+\2\u0682") + buf.write("\u0688\7!\2\2\u0683\u0684\7@\2\2\u0684\u0685\7\b\2\2\u0685") + buf.write("\u0686\5\u00ccg\2\u0686\u0687\7!\2\2\u0687\u0689\3\2\2") + buf.write("\2\u0688\u0683\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068e") + buf.write("\3\2\2\2\u068a\u068b\7t\2\2\u068b\u068c\7\b\2\2\u068c") + buf.write("\u068d\7\u00fa\2\2\u068d\u068f\7!\2\2\u068e\u068a\3\2") + buf.write("\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u0691") + buf.write("\5\u00caf\2\u0691\u0692\5\u00b4[\2\u0692\u0693\7_\2\2") + buf.write("\u0693\u0694\7 \2\2\u0694\u00c9\3\2\2\2\u0695\u0696\7") + buf.write("`\2\2\u0696\u0698\7\b\2\2\u0697\u0699\7\35\2\2\u0698\u0697") + buf.write("\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u069a\3\2\2\2\u069a") + buf.write("\u069b\7\u00fa\2\2\u069b\u069c\7!\2\2\u069c\u069d\7a\2") + buf.write("\2\u069d\u069f\7\b\2\2\u069e\u06a0\7\35\2\2\u069f\u069e") + buf.write("\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1") + buf.write("\u06a2\7\u00fa\2\2\u06a2\u06a7\7!\2\2\u06a3\u06a4\7b\2") + buf.write("\2\u06a4\u06a5\7\b\2\2\u06a5\u06a6\7\u00fa\2\2\u06a6\u06a8") + buf.write("\7!\2\2\u06a7\u06a3\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8") + buf.write("\u00cb\3\2\2\2\u06a9\u06ae\5\u00ceh\2\u06aa\u06ab\7(\2") + buf.write("\2\u06ab\u06ad\5\u00ceh\2\u06ac\u06aa\3\2\2\2\u06ad\u06b0") + buf.write("\3\2\2\2\u06ae\u06ac\3\2\2\2\u06ae\u06af\3\2\2\2\u06af") + buf.write("\u00cd\3\2\2\2\u06b0\u06ae\3\2\2\2\u06b1\u06bb\7\u00fa") + buf.write("\2\2\u06b2\u06bb\7\u00ef\2\2\u06b3\u06bb\7\u00f0\2\2\u06b4") + buf.write("\u06bb\7\u00f1\2\2\u06b5\u06bb\7\u00f2\2\2\u06b6\u06bb") + buf.write("\7\u00f3\2\2\u06b7\u06bb\7\u00f4\2\2\u06b8\u06bb\7\u00f5") + buf.write("\2\2\u06b9\u06bb\5V,\2\u06ba\u06b1\3\2\2\2\u06ba\u06b2") + buf.write("\3\2\2\2\u06ba\u06b3\3\2\2\2\u06ba\u06b4\3\2\2\2\u06ba") + buf.write("\u06b5\3\2\2\2\u06ba\u06b6\3\2\2\2\u06ba\u06b7\3\2\2\2") + buf.write("\u06ba\u06b8\3\2\2\2\u06ba\u06b9\3\2\2\2\u06bb\u00cf\3") + buf.write("\2\2\2\u06bc\u06bd\7\60\2\2\u06bd\u06be\5R*\2\u06be\u06bf") + buf.write("\5T+\2\u06bf\u06c5\7!\2\2\u06c0\u06c1\7@\2\2\u06c1\u06c2") + buf.write("\7\b\2\2\u06c2\u06c3\5\u00d2j\2\u06c3\u06c4\7!\2\2\u06c4") + buf.write("\u06c6\3\2\2\2\u06c5\u06c0\3\2\2\2\u06c5\u06c6\3\2\2\2") + buf.write("\u06c6\u06c8\3\2\2\2\u06c7\u06c9\5\u00caf\2\u06c8\u06c7") + buf.write("\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca") + buf.write("\u06cb\5\u00b4[\2\u06cb\u06cc\7\61\2\2\u06cc\u06cd\7 ") + buf.write("\2\2\u06cd\u00d1\3\2\2\2\u06ce\u06d3\5\u00ceh\2\u06cf") + buf.write("\u06d0\7(\2\2\u06d0\u06d2\5\u00ceh\2\u06d1\u06cf\3\2\2") + buf.write("\2\u06d2\u06d5\3\2\2\2\u06d3\u06d1\3\2\2\2\u06d3\u06d4") + buf.write("\3\2\2\2\u06d4\u00d3\3\2\2\2\u06d5\u06d3\3\2\2\2\u06d6") + buf.write("\u06d9\5\u00d6l\2\u06d7\u06d9\5\u00dco\2\u06d8\u06d6\3") + buf.write("\2\2\2\u06d8\u06d7\3\2\2\2\u06d9\u00d5\3\2\2\2\u06da\u06db") + buf.write("\7f\2\2\u06db\u06dc\5P)\2\u06dc\u06e2\7!\2\2\u06dd\u06de") + buf.write("\7@\2\2\u06de\u06df\7\b\2\2\u06df\u06e0\5\u00d8m\2\u06e0") + buf.write("\u06e1\7!\2\2\u06e1\u06e3\3\2\2\2\u06e2\u06dd\3\2\2\2") + buf.write("\u06e2\u06e3\3\2\2\2\u06e3\u06e8\3\2\2\2\u06e4\u06e5\7") + buf.write("t\2\2\u06e5\u06e6\7\b\2\2\u06e6\u06e7\7\u00fa\2\2\u06e7") + buf.write("\u06e9\7!\2\2\u06e8\u06e4\3\2\2\2\u06e8\u06e9\3\2\2\2") + buf.write("\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7h\2\2\u06eb\u06ec\7") + buf.write("\b\2\2\u06ec\u06ed\7\u00fa\2\2\u06ed\u06ee\7!\2\2\u06ee") + buf.write("\u06ef\7i\2\2\u06ef\u06f0\7\b\2\2\u06f0\u06f1\7\u00fa") + buf.write("\2\2\u06f1\u06f2\7!\2\2\u06f2\u06f3\5\u00b4[\2\u06f3\u06f4") + buf.write("\7g\2\2\u06f4\u06f5\7 \2\2\u06f5\u00d7\3\2\2\2\u06f6\u06fb") + buf.write("\5\u00dan\2\u06f7\u06f8\7(\2\2\u06f8\u06fa\5\u00dan\2") + buf.write("\u06f9\u06f7\3\2\2\2\u06fa\u06fd\3\2\2\2\u06fb\u06f9\3") + buf.write("\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u00d9\3\2\2\2\u06fd\u06fb") + buf.write("\3\2\2\2\u06fe\u0702\7\u00fa\2\2\u06ff\u0702\7\13\2\2") + buf.write("\u0700\u0702\5V,\2\u0701\u06fe\3\2\2\2\u0701\u06ff\3\2") + buf.write("\2\2\u0701\u0700\3\2\2\2\u0702\u00db\3\2\2\2\u0703\u0704") + buf.write("\7d\2\2\u0704\u0705\5P)\2\u0705\u070b\7!\2\2\u0706\u0707") + buf.write("\7@\2\2\u0707\u0708\7\b\2\2\u0708\u0709\5\u00dep\2\u0709") + buf.write("\u070a\7!\2\2\u070a\u070c\3\2\2\2\u070b\u0706\3\2\2\2") + buf.write("\u070b\u070c\3\2\2\2\u070c\u0711\3\2\2\2\u070d\u070e\7") + buf.write("t\2\2\u070e\u070f\7\b\2\2\u070f\u0710\7\u00fa\2\2\u0710") + buf.write("\u0712\7!\2\2\u0711\u070d\3\2\2\2\u0711\u0712\3\2\2\2") + buf.write("\u0712\u0713\3\2\2\2\u0713\u0714\7h\2\2\u0714\u0715\7") + buf.write("\b\2\2\u0715\u0716\7\u00fa\2\2\u0716\u0717\7!\2\2\u0717") + buf.write("\u0718\7i\2\2\u0718\u0719\7\b\2\2\u0719\u071a\7\u00fa") + buf.write("\2\2\u071a\u071f\7!\2\2\u071b\u071c\7j\2\2\u071c\u071d") + buf.write("\7\b\2\2\u071d\u071e\7\u00fa\2\2\u071e\u0720\7!\2\2\u071f") + buf.write("\u071b\3\2\2\2\u071f\u0720\3\2\2\2\u0720\u0721\3\2\2\2") + buf.write("\u0721\u0722\5\u00b4[\2\u0722\u0723\7e\2\2\u0723\u0724") + buf.write("\7 \2\2\u0724\u00dd\3\2\2\2\u0725\u072a\5\u00e0q\2\u0726") + buf.write("\u0727\7(\2\2\u0727\u0729\5\u00e0q\2\u0728\u0726\3\2\2") + buf.write("\2\u0729\u072c\3\2\2\2\u072a\u0728\3\2\2\2\u072a\u072b") + buf.write("\3\2\2\2\u072b\u00df\3\2\2\2\u072c\u072a\3\2\2\2\u072d") + buf.write("\u0730\7\u00fa\2\2\u072e\u0730\5V,\2\u072f\u072d\3\2\2") + buf.write("\2\u072f\u072e\3\2\2\2\u0730\u00e1\3\2\2\2\u0731\u0732") + buf.write("\7\63\2\2\u0732\u0733\5P)\2\u0733\u0738\7!\2\2\u0734\u0735") + buf.write("\7\64\2\2\u0735\u0736\7\b\2\2\u0736\u0737\7\u00fa\2\2") + buf.write("\u0737\u0739\7!\2\2\u0738\u0734\3\2\2\2\u0738\u0739\3") + buf.write("\2\2\2\u0739\u073f\3\2\2\2\u073a\u073b\7@\2\2\u073b\u073c") + buf.write("\7\b\2\2\u073c\u073d\5\u00e4s\2\u073d\u073e\7!\2\2\u073e") + buf.write("\u0740\3\2\2\2\u073f\u073a\3\2\2\2\u073f\u0740\3\2\2\2") + buf.write("\u0740\u0741\3\2\2\2\u0741\u0742\5\u00b4[\2\u0742\u0743") + buf.write("\7\65\2\2\u0743\u0744\7 \2\2\u0744\u00e3\3\2\2\2\u0745") + buf.write("\u074a\5\u00e6t\2\u0746\u0747\7(\2\2\u0747\u0749\5\u00e6") + buf.write("t\2\u0748\u0746\3\2\2\2\u0749\u074c\3\2\2\2\u074a\u0748") + buf.write("\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u00e5\3\2\2\2\u074c") + buf.write("\u074a\3\2\2\2\u074d\u0752\7\u00fa\2\2\u074e\u0752\7\u00c0") + buf.write("\2\2\u074f\u0752\7\u00c1\2\2\u0750\u0752\5V,\2\u0751\u074d") + buf.write("\3\2\2\2\u0751\u074e\3\2\2\2\u0751\u074f\3\2\2\2\u0751") + buf.write("\u0750\3\2\2\2\u0752\u00e7\3\2\2\2\u0753\u07ae\7A\2\2") + buf.write("\u0754\u0755\5P)\2\u0755\u075b\7!\2\2\u0756\u0757\7@\2") + buf.write("\2\u0757\u0758\7\b\2\2\u0758\u0759\5\u00ecw\2\u0759\u075a") + buf.write("\7!\2\2\u075a\u075c\3\2\2\2\u075b\u0756\3\2\2\2\u075b") + buf.write("\u075c\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u075e\5\u00b4") + buf.write("[\2\u075e\u07af\3\2\2\2\u075f\u0760\7C\2\2\u0760\u0761") + buf.write("\7\u008f\2\2\u0761\u0762\7\b\2\2\u0762\u0763\7\u00fb\2") + buf.write("\2\u0763\u0764\7\34\2\2\u0764\u0765\7\u00fb\2\2\u0765") + buf.write("\u0766\7!\2\2\u0766\u0767\7\62\2\2\u0767\u0768\7\b\2\2") + buf.write("\u0768\u0769\7\u00ec\2\2\u0769\u076a\7\30\2\2\u076a\u076b") + buf.write("\7\u00fa\2\2\u076b\u076c\7\31\2\2\u076c\u076d\7!\2\2\u076d") + buf.write("\u076e\7=\2\2\u076e\u076f\7\b\2\2\u076f\u0770\7\u00ec") + buf.write("\2\2\u0770\u0771\7\30\2\2\u0771\u0772\7\u00fa\2\2\u0772") + buf.write("\u0773\7\31\2\2\u0773\u0774\7!\2\2\u0774\u0775\5\u00ea") + buf.write("v\2\u0775\u0776\7D\2\2\u0776\u0777\7\u008f\2\2\u0777\u0778") + buf.write("\7\b\2\2\u0778\u0779\7\u00fb\2\2\u0779\u077a\7\34\2\2") + buf.write("\u077a\u077b\7\u00fb\2\2\u077b\u077c\7!\2\2\u077c\u077d") + buf.write("\7\62\2\2\u077d\u077e\7\b\2\2\u077e\u077f\7\u00ec\2\2") + buf.write("\u077f\u0780\7\30\2\2\u0780\u0781\7\u00fa\2\2\u0781\u0782") + buf.write("\7\31\2\2\u0782\u0783\7!\2\2\u0783\u0784\7=\2\2\u0784") + buf.write("\u0785\7\b\2\2\u0785\u0786\7\u00ec\2\2\u0786\u0787\7\30") + buf.write("\2\2\u0787\u0788\7\u00fa\2\2\u0788\u0789\7\31\2\2\u0789") + buf.write("\u078a\7!\2\2\u078a\u078b\5\u00eav\2\u078b\u078c\7E\2") + buf.write("\2\u078c\u078d\7\u008f\2\2\u078d\u078e\7\b\2\2\u078e\u078f") + buf.write("\7\u00fb\2\2\u078f\u0790\7\34\2\2\u0790\u0791\7\u00fb") + buf.write("\2\2\u0791\u0792\7!\2\2\u0792\u0793\7\62\2\2\u0793\u0794") + buf.write("\7\b\2\2\u0794\u0795\7\u00ec\2\2\u0795\u0796\7\30\2\2") + buf.write("\u0796\u0797\7\u00fa\2\2\u0797\u0798\7\31\2\2\u0798\u0799") + buf.write("\7!\2\2\u0799\u079a\7=\2\2\u079a\u079b\7\b\2\2\u079b\u079c") + buf.write("\7\u00ec\2\2\u079c\u079d\7\30\2\2\u079d\u079e\7\u00fa") + buf.write("\2\2\u079e\u079f\7\31\2\2\u079f\u07a0\7!\2\2\u07a0\u07a6") + buf.write("\5\u00eav\2\u07a1\u07a2\7@\2\2\u07a2\u07a3\7\b\2\2\u07a3") + buf.write("\u07a4\5\u00ecw\2\u07a4\u07a5\7!\2\2\u07a5\u07a7\3\2\2") + buf.write("\2\u07a6\u07a1\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07ab") + buf.write("\3\2\2\2\u07a8\u07aa\5\u008cG\2\u07a9\u07a8\3\2\2\2\u07aa") + buf.write("\u07ad\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac\3\2\2\2") + buf.write("\u07ac\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ae\u0754\3") + buf.write("\2\2\2\u07ae\u075f\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1") + buf.write("\7B\2\2\u07b1\u07b2\7 \2\2\u07b2\u00e9\3\2\2\2\u07b3\u07b4") + buf.write("\7`\2\2\u07b4\u07b5\7\b\2\2\u07b5\u07b6\7\u00fa\2\2\u07b6") + buf.write("\u07b7\7!\2\2\u07b7\u07b8\7a\2\2\u07b8\u07b9\7\b\2\2\u07b9") + buf.write("\u07ba\7\u00fa\2\2\u07ba\u07bf\7!\2\2\u07bb\u07bc\7b\2") + buf.write("\2\u07bc\u07bd\7\b\2\2\u07bd\u07be\7\u00fa\2\2\u07be\u07c0") + buf.write("\7!\2\2\u07bf\u07bb\3\2\2\2\u07bf\u07c0\3\2\2\2\u07c0") + buf.write("\u07c5\3\2\2\2\u07c1\u07c2\7c\2\2\u07c2\u07c3\7\b\2\2") + buf.write("\u07c3\u07c4\7\u00fa\2\2\u07c4\u07c6\7!\2\2\u07c5\u07c1") + buf.write("\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u00eb\3\2\2\2\u07c7") + buf.write("\u07cc\5\u00eex\2\u07c8\u07c9\7(\2\2\u07c9\u07cb\5\u00ee") + buf.write("x\2\u07ca\u07c8\3\2\2\2\u07cb\u07ce\3\2\2\2\u07cc\u07ca") + buf.write("\3\2\2\2\u07cc\u07cd\3\2\2\2\u07cd\u00ed\3\2\2\2\u07ce") + buf.write("\u07cc\3\2\2\2\u07cf\u07d0\t\6\2\2\u07d0\u00ef\3\2\2\2") + buf.write("\u07d1\u082c\7F\2\2\u07d2\u07d3\5P)\2\u07d3\u07d9\7!\2") + buf.write("\2\u07d4\u07d5\7@\2\2\u07d5\u07d6\7\b\2\2\u07d6\u07d7") + buf.write("\5\u00f4{\2\u07d7\u07d8\7!\2\2\u07d8\u07da\3\2\2\2\u07d9") + buf.write("\u07d4\3\2\2\2\u07d9\u07da\3\2\2\2\u07da\u07db\3\2\2\2") + buf.write("\u07db\u07dc\5\u00b4[\2\u07dc\u082d\3\2\2\2\u07dd\u07de") + buf.write("\7H\2\2\u07de\u07df\7\u008f\2\2\u07df\u07e0\7\b\2\2\u07e0") + buf.write("\u07e1\7\u00fb\2\2\u07e1\u07e2\7\34\2\2\u07e2\u07e3\7") + buf.write("\u00fb\2\2\u07e3\u07e4\7!\2\2\u07e4\u07e5\7\62\2\2\u07e5") + buf.write("\u07e6\7\b\2\2\u07e6\u07e7\7\u00ec\2\2\u07e7\u07e8\7\30") + buf.write("\2\2\u07e8\u07e9\7\u00fa\2\2\u07e9\u07ea\7\31\2\2\u07ea") + buf.write("\u07eb\7!\2\2\u07eb\u07ec\7=\2\2\u07ec\u07ed\7\b\2\2\u07ed") + buf.write("\u07ee\7\u00ec\2\2\u07ee\u07ef\7\30\2\2\u07ef\u07f0\7") + buf.write("\u00fa\2\2\u07f0\u07f1\7\31\2\2\u07f1\u07f2\7!\2\2\u07f2") + buf.write("\u07f3\5\u00f2z\2\u07f3\u07f4\7I\2\2\u07f4\u07f5\7\u008f") + buf.write("\2\2\u07f5\u07f6\7\b\2\2\u07f6\u07f7\7\u00fb\2\2\u07f7") + buf.write("\u07f8\7\34\2\2\u07f8\u07f9\7\u00fb\2\2\u07f9\u07fa\7") + buf.write("!\2\2\u07fa\u07fb\7\62\2\2\u07fb\u07fc\7\b\2\2\u07fc\u07fd") + buf.write("\7\u00ec\2\2\u07fd\u07fe\7\30\2\2\u07fe\u07ff\7\u00fa") + buf.write("\2\2\u07ff\u0800\7\31\2\2\u0800\u0801\7!\2\2\u0801\u0802") + buf.write("\7=\2\2\u0802\u0803\7\b\2\2\u0803\u0804\7\u00ec\2\2\u0804") + buf.write("\u0805\7\30\2\2\u0805\u0806\7\u00fa\2\2\u0806\u0807\7") + buf.write("\31\2\2\u0807\u0808\7!\2\2\u0808\u0809\5\u00f2z\2\u0809") + buf.write("\u080a\7J\2\2\u080a\u080b\7\u008f\2\2\u080b\u080c\7\b") + buf.write("\2\2\u080c\u080d\7\u00fb\2\2\u080d\u080e\7\34\2\2\u080e") + buf.write("\u080f\7\u00fb\2\2\u080f\u0810\7!\2\2\u0810\u0811\7\62") + buf.write("\2\2\u0811\u0812\7\b\2\2\u0812\u0813\7\u00ec\2\2\u0813") + buf.write("\u0814\7\30\2\2\u0814\u0815\7\u00fa\2\2\u0815\u0816\7") + buf.write("\31\2\2\u0816\u0817\7!\2\2\u0817\u0818\7=\2\2\u0818\u0819") + buf.write("\7\b\2\2\u0819\u081a\7\u00ec\2\2\u081a\u081b\7\30\2\2") + buf.write("\u081b\u081c\7\u00fa\2\2\u081c\u081d\7\31\2\2\u081d\u081e") + buf.write("\7!\2\2\u081e\u0824\5\u00f2z\2\u081f\u0820\7@\2\2\u0820") + buf.write("\u0821\7\b\2\2\u0821\u0822\5\u00f4{\2\u0822\u0823\7!\2") + buf.write("\2\u0823\u0825\3\2\2\2\u0824\u081f\3\2\2\2\u0824\u0825") + buf.write("\3\2\2\2\u0825\u0829\3\2\2\2\u0826\u0828\5\u008cG\2\u0827") + buf.write("\u0826\3\2\2\2\u0828\u082b\3\2\2\2\u0829\u0827\3\2\2\2") + buf.write("\u0829\u082a\3\2\2\2\u082a\u082d\3\2\2\2\u082b\u0829\3") + buf.write("\2\2\2\u082c\u07d2\3\2\2\2\u082c\u07dd\3\2\2\2\u082d\u082e") + buf.write("\3\2\2\2\u082e\u082f\7G\2\2\u082f\u0830\7 \2\2\u0830\u00f1") + buf.write("\3\2\2\2\u0831\u0832\7`\2\2\u0832\u0833\7\b\2\2\u0833") + buf.write("\u0834\7\u00fa\2\2\u0834\u0835\7!\2\2\u0835\u0836\7a\2") + buf.write("\2\u0836\u0837\7\b\2\2\u0837\u0838\7\u00fa\2\2\u0838\u083d") + buf.write("\7!\2\2\u0839\u083a\7b\2\2\u083a\u083b\7\b\2\2\u083b\u083c") + buf.write("\7\u00fa\2\2\u083c\u083e\7!\2\2\u083d\u0839\3\2\2\2\u083d") + buf.write("\u083e\3\2\2\2\u083e\u0843\3\2\2\2\u083f\u0840\7c\2\2") + buf.write("\u0840\u0841\7\b\2\2\u0841\u0842\7\u00fa\2\2\u0842\u0844") + buf.write("\7!\2\2\u0843\u083f\3\2\2\2\u0843\u0844\3\2\2\2\u0844") + buf.write("\u00f3\3\2\2\2\u0845\u084a\5\u00f6|\2\u0846\u0847\7(\2") + buf.write("\2\u0847\u0849\5\u00f6|\2\u0848\u0846\3\2\2\2\u0849\u084c") + buf.write("\3\2\2\2\u084a\u0848\3\2\2\2\u084a\u084b\3\2\2\2\u084b") + buf.write("\u00f5\3\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\t\7\2\2") + buf.write("\u084e\u00f7\3\2\2\2\u084f\u0854\5\u0104\u0083\2\u0850") + buf.write("\u0854\5\u00fc\177\2\u0851\u0854\5\u00fe\u0080\2\u0852") + buf.write("\u0854\5\u010e\u0088\2\u0853\u084f\3\2\2\2\u0853\u0850") + buf.write("\3\2\2\2\u0853\u0851\3\2\2\2\u0853\u0852\3\2\2\2\u0854") + buf.write("\u00f9\3\2\2\2\u0855\u0856\5\u0104\u0083\2\u0856\u0857") + buf.write("\5\u010a\u0086\2\u0857\u0858\5\u010c\u0087\2\u0858\u0859") + buf.write("\5\u010e\u0088\2\u0859\u00fb\3\2\2\2\u085a\u085b\5\u010a") + buf.write("\u0086\2\u085b\u00fd\3\2\2\2\u085c\u085d\5\u010c\u0087") + buf.write("\2\u085d\u00ff\3\2\2\2\u085e\u0865\5p9\2\u085f\u0865\5") + buf.write("\u0088E\2\u0860\u0865\5\u00f8}\2\u0861\u0865\5\u0118\u008d") + buf.write("\2\u0862\u0865\5\u011c\u008f\2\u0863\u0865\5\u0110\u0089") + buf.write("\2\u0864\u085e\3\2\2\2\u0864\u085f\3\2\2\2\u0864\u0860") + buf.write("\3\2\2\2\u0864\u0861\3\2\2\2\u0864\u0862\3\2\2\2\u0864") + buf.write("\u0863\3\2\2\2\u0865\u0101\3\2\2\2\u0866\u086b\5p9\2\u0867") + buf.write("\u086b\5\u0088E\2\u0868\u086b\5\u0118\u008d\2\u0869\u086b") + buf.write("\5\u0110\u0089\2\u086a\u0866\3\2\2\2\u086a\u0867\3\2\2") + buf.write("\2\u086a\u0868\3\2\2\2\u086a\u0869\3\2\2\2\u086b\u0103") + buf.write("\3\2\2\2\u086c\u086d\7l\2\2\u086d\u086e\5\u0124\u0093") + buf.write("\2\u086e\u0872\7 \2\2\u086f\u0871\5\u0100\u0081\2\u0870") + buf.write("\u086f\3\2\2\2\u0871\u0874\3\2\2\2\u0872\u0870\3\2\2\2") + buf.write("\u0872\u0873\3\2\2\2\u0873\u0875\3\2\2\2\u0874\u0872\3") + buf.write("\2\2\2\u0875\u0876\7s\2\2\u0876\u0877\7 \2\2\u0877\u0105") + buf.write("\3\2\2\2\u0878\u0885\7k\2\2\u0879\u087a\7@\2\2\u087a\u087b") + buf.write("\7\b\2\2\u087b\u0880\5\u009eP\2\u087c\u087d\7(\2\2\u087d") + buf.write("\u087f\5\u009eP\2\u087e\u087c\3\2\2\2\u087f\u0882\3\2") + buf.write("\2\2\u0880\u087e\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0883") + buf.write("\3\2\2\2\u0882\u0880\3\2\2\2\u0883\u0884\7!\2\2\u0884") + buf.write("\u0886\3\2\2\2\u0885\u0879\3\2\2\2\u0885\u0886\3\2\2\2") + buf.write("\u0886\u0887\3\2\2\2\u0887\u0888\5\u0124\u0093\2\u0888") + buf.write("\u0889\7 \2\2\u0889\u0107\3\2\2\2\u088a\u0897\7K\2\2\u088b") + buf.write("\u088c\7@\2\2\u088c\u088d\7\b\2\2\u088d\u0892\5\u009e") + buf.write("P\2\u088e\u088f\7(\2\2\u088f\u0891\5\u009eP\2\u0890\u088e") + buf.write("\3\2\2\2\u0891\u0894\3\2\2\2\u0892\u0890\3\2\2\2\u0892") + buf.write("\u0893\3\2\2\2\u0893\u0895\3\2\2\2\u0894\u0892\3\2\2\2") + buf.write("\u0895\u0896\7!\2\2\u0896\u0898\3\2\2\2\u0897\u088b\3") + buf.write("\2\2\2\u0897\u0898\3\2\2\2\u0898\u0899\3\2\2\2\u0899\u089a") + buf.write("\5\u0124\u0093\2\u089a\u089b\7 \2\2\u089b\u0109\3\2\2") + buf.write("\2\u089c\u08a9\7k\2\2\u089d\u089e\7@\2\2\u089e\u089f\7") + buf.write("\b\2\2\u089f\u08a4\5\u009eP\2\u08a0\u08a1\7(\2\2\u08a1") + buf.write("\u08a3\5\u009eP\2\u08a2\u08a0\3\2\2\2\u08a3\u08a6\3\2") + buf.write("\2\2\u08a4\u08a2\3\2\2\2\u08a4\u08a5\3\2\2\2\u08a5\u08a7") + buf.write("\3\2\2\2\u08a6\u08a4\3\2\2\2\u08a7\u08a8\7!\2\2\u08a8") + buf.write("\u08aa\3\2\2\2\u08a9\u089d\3\2\2\2\u08a9\u08aa\3\2\2\2") + buf.write("\u08aa\u08ab\3\2\2\2\u08ab\u08ac\5\u0124\u0093\2\u08ac") + buf.write("\u08b0\7 \2\2\u08ad\u08af\5\u0100\u0081\2\u08ae\u08ad") + buf.write("\3\2\2\2\u08af\u08b2\3\2\2\2\u08b0\u08ae\3\2\2\2\u08b0") + buf.write("\u08b1\3\2\2\2\u08b1\u08b3\3\2\2\2\u08b2\u08b0\3\2\2\2") + buf.write("\u08b3\u08b4\7s\2\2\u08b4\u08b5\7 \2\2\u08b5\u010b\3\2") + buf.write("\2\2\u08b6\u08c3\7K\2\2\u08b7\u08b8\7@\2\2\u08b8\u08b9") + buf.write("\7\b\2\2\u08b9\u08be\5\u009eP\2\u08ba\u08bb\7(\2\2\u08bb") + buf.write("\u08bd\5\u009eP\2\u08bc\u08ba\3\2\2\2\u08bd\u08c0\3\2") + buf.write("\2\2\u08be\u08bc\3\2\2\2\u08be\u08bf\3\2\2\2\u08bf\u08c1") + buf.write("\3\2\2\2\u08c0\u08be\3\2\2\2\u08c1\u08c2\7!\2\2\u08c2") + buf.write("\u08c4\3\2\2\2\u08c3\u08b7\3\2\2\2\u08c3\u08c4\3\2\2\2") + buf.write("\u08c4\u08c5\3\2\2\2\u08c5\u08c6\5\u0124\u0093\2\u08c6") + buf.write("\u08ca\7 \2\2\u08c7\u08c9\5\u0100\u0081\2\u08c8\u08c7") + buf.write("\3\2\2\2\u08c9\u08cc\3\2\2\2\u08ca\u08c8\3\2\2\2\u08ca") + buf.write("\u08cb\3\2\2\2\u08cb\u08cd\3\2\2\2\u08cc\u08ca\3\2\2\2") + buf.write("\u08cd\u08ce\7s\2\2\u08ce\u08cf\7 \2\2\u08cf\u010d\3\2") + buf.write("\2\2\u08d0\u08d1\7p\2\2\u08d1\u08d2\7\62\2\2\u08d2\u08d3") + buf.write("\7\b\2\2\u08d3\u08d4\7\u00ec\2\2\u08d4\u08d5\7\30\2\2") + buf.write("\u08d5\u08d6\7\u00fa\2\2\u08d6\u08d7\7\31\2\2\u08d7\u08e4") + buf.write("\7!\2\2\u08d8\u08d9\7@\2\2\u08d9\u08da\7\b\2\2\u08da\u08df") + buf.write("\5\u009eP\2\u08db\u08dc\7(\2\2\u08dc\u08de\5\u009eP\2") + buf.write("\u08dd\u08db\3\2\2\2\u08de\u08e1\3\2\2\2\u08df\u08dd\3") + buf.write("\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08e2\3\2\2\2\u08e1\u08df") + buf.write("\3\2\2\2\u08e2\u08e3\7!\2\2\u08e3\u08e5\3\2\2\2\u08e4") + buf.write("\u08d8\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5\u08e6\3\2\2\2") + buf.write("\u08e6\u08e7\5\u0124\u0093\2\u08e7\u08e8\7s\2\2\u08e8") + buf.write("\u08e9\7 \2\2\u08e9\u010f\3\2\2\2\u08ea\u08ee\5\u0112") + buf.write("\u008a\2\u08eb\u08ee\5\u0114\u008b\2\u08ec\u08ee\5\u0116") + buf.write("\u008c\2\u08ed\u08ea\3\2\2\2\u08ed\u08eb\3\2\2\2\u08ed") + buf.write("\u08ec\3\2\2\2\u08ee\u0111\3\2\2\2\u08ef\u08f0\7m\2\2") + buf.write("\u08f0\u08f1\7\u0096\2\2\u08f1\u08f2\7\b\2\2\u08f2\u08f3") + buf.write("\7\u00fa\2\2\u08f3\u08f4\7!\2\2\u08f4\u08f5\7t\2\2\u08f5") + buf.write("\u08f6\7\b\2\2\u08f6\u08f7\7\u00fa\2\2\u08f7\u08f8\7 ") + buf.write("\2\2\u08f8\u0113\3\2\2\2\u08f9\u08fa\7N\2\2\u08fa\u08fb") + buf.write("\7=\2\2\u08fb\u08fc\7\b\2\2\u08fc\u08fd\7\u00ec\2\2\u08fd") + buf.write("\u08fe\7\30\2\2\u08fe\u08ff\7\u00fa\2\2\u08ff\u0900\7") + buf.write("\31\2\2\u0900\u0901\7!\2\2\u0901\u0902\7>\2\2\u0902\u0903") + buf.write("\7\b\2\2\u0903\u0904\7\u00ec\2\2\u0904\u0905\7\30\2\2") + buf.write("\u0905\u0906\7\u00fa\2\2\u0906\u0907\7\31\2\2\u0907\u090e") + buf.write("\7!\2\2\u0908\u0909\7>\2\2\u0909\u090a\7\b\2\2\u090a\u090b") + buf.write("\7\u00ec\2\2\u090b\u090c\7\30\2\2\u090c\u090d\7\u00fa") + buf.write("\2\2\u090d\u090f\7\31\2\2\u090e\u0908\3\2\2\2\u090e\u090f") + buf.write("\3\2\2\2\u090f\u0910\3\2\2\2\u0910\u0911\7 \2\2\u0911") + buf.write("\u0115\3\2\2\2\u0912\u0913\t\b\2\2\u0913\u0914\7\u0087") + buf.write("\2\2\u0914\u0915\7!\2\2\u0915\u0916\7/\2\2\u0916\u0917") + buf.write("\7\b\2\2\u0917\u0918\7\u00fa\2\2\u0918\u0919\7!\2\2\u0919") + buf.write("\u091a\7\62\2\2\u091a\u091b\7\b\2\2\u091b\u091c\7\u00ec") + buf.write("\2\2\u091c\u091d\7\30\2\2\u091d\u091e\7\u00fa\2\2\u091e") + buf.write("\u091f\7\31\2\2\u091f\u0920\7!\2\2\u0920\u0921\7=\2\2") + buf.write("\u0921\u0922\7\b\2\2\u0922\u0923\7\u00ec\2\2\u0923\u0924") + buf.write("\7\30\2\2\u0924\u0925\7\u00fa\2\2\u0925\u0931\7\31\2\2") + buf.write("\u0926\u0927\7!\2\2\u0927\u0928\7@\2\2\u0928\u0929\7\b") + buf.write("\2\2\u0929\u092e\5\u009eP\2\u092a\u092b\7(\2\2\u092b\u092d") + buf.write("\5\u009eP\2\u092c\u092a\3\2\2\2\u092d\u0930\3\2\2\2\u092e") + buf.write("\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0932\3\2\2\2") + buf.write("\u0930\u092e\3\2\2\2\u0931\u0926\3\2\2\2\u0931\u0932\3") + buf.write("\2\2\2\u0932\u0937\3\2\2\2\u0933\u0934\7!\2\2\u0934\u0935") + buf.write("\7t\2\2\u0935\u0936\7\b\2\2\u0936\u0938\7\u00fa\2\2\u0937") + buf.write("\u0933\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\3\2\2\2") + buf.write("\u0939\u093a\7 \2\2\u093a\u0117\3\2\2\2\u093b\u093c\7") + buf.write("L\2\2\u093c\u093d\7\u00fa\2\2\u093d\u093e\7 \2\2\u093e") + buf.write("\u0119\3\2\2\2\u093f\u0941\7\u0088\2\2\u0940\u0942\7!") + buf.write("\2\2\u0941\u0940\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u0943") + buf.write("\3\2\2\2\u0943\u0944\7.\2\2\u0944\u0945\7\b\2\2\u0945") + buf.write("\u0946\7\u00ec\2\2\u0946\u0947\7\30\2\2\u0947\u0948\7") + buf.write("\u00fa\2\2\u0948\u0949\7\31\2\2\u0949\u0954\7!\2\2\u094a") + buf.write("\u094b\7\u008d\2\2\u094b\u094c\7\u00fa\2\2\u094c\u094d") + buf.write("\7!\2\2\u094d\u094e\7\u0089\2\2\u094e\u094f\t\t\2\2\u094f") + buf.write("\u0955\7 \2\2\u0950\u0951\7M\2\2\u0951\u0952\7\b\2\2\u0952") + buf.write("\u0953\7\u00fa\2\2\u0953\u0955\7 \2\2\u0954\u094a\3\2") + buf.write("\2\2\u0954\u0950\3\2\2\2\u0955\u011b\3\2\2\2\u0956\u0957") + buf.write("\7\u00a7\2\2\u0957\u0958\7[\2\2\u0958\u0959\7\b\2\2\u0959") + buf.write("\u09a1\5L\'\2\u095a\u095b\7!\2\2\u095b\u095c\7\u00a9\2") + buf.write("\2\u095c\u0999\7\b\2\2\u095d\u0961\7S\2\2\u095e\u095f") + buf.write("\7\32\2\2\u095f\u0960\7\u00fa\2\2\u0960\u0962\7\33\2\2") + buf.write("\u0961\u095e\3\2\2\2\u0961\u0962\3\2\2\2\u0962\u099a\3") + buf.write("\2\2\2\u0963\u0967\7T\2\2\u0964\u0965\7\32\2\2\u0965\u0966") + buf.write("\7\u00fa\2\2\u0966\u0968\7\33\2\2\u0967\u0964\3\2\2\2") + buf.write("\u0967\u0968\3\2\2\2\u0968\u099a\3\2\2\2\u0969\u096d\7") + buf.write("U\2\2\u096a\u096b\7\32\2\2\u096b\u096c\7\u00fa\2\2\u096c") + buf.write("\u096e\7\33\2\2\u096d\u096a\3\2\2\2\u096d\u096e\3\2\2") + buf.write("\2\u096e\u099a\3\2\2\2\u096f\u0973\7V\2\2\u0970\u0971") + buf.write("\7\32\2\2\u0971\u0972\7\u00fa\2\2\u0972\u0974\7\33\2\2") + buf.write("\u0973\u0970\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u099a\3") + buf.write("\2\2\2\u0975\u0979\7R\2\2\u0976\u0977\7\32\2\2\u0977\u0978") + buf.write("\7\u00fa\2\2\u0978\u097a\7\33\2\2\u0979\u0976\3\2\2\2") + buf.write("\u0979\u097a\3\2\2\2\u097a\u099a\3\2\2\2\u097b\u097f\7") + buf.write("W\2\2\u097c\u097d\7\32\2\2\u097d\u097e\7\u00fa\2\2\u097e") + buf.write("\u0980\7\33\2\2\u097f\u097c\3\2\2\2\u097f\u0980\3\2\2") + buf.write("\2\u0980\u099a\3\2\2\2\u0981\u0985\7X\2\2\u0982\u0983") + buf.write("\7\32\2\2\u0983\u0984\7\u00fa\2\2\u0984\u0986\7\33\2\2") + buf.write("\u0985\u0982\3\2\2\2\u0985\u0986\3\2\2\2\u0986\u099a\3") + buf.write("\2\2\2\u0987\u098b\7Y\2\2\u0988\u0989\7\32\2\2\u0989\u098a") + buf.write("\7\u00fa\2\2\u098a\u098c\7\33\2\2\u098b\u0988\3\2\2\2") + buf.write("\u098b\u098c\3\2\2\2\u098c\u099a\3\2\2\2\u098d\u0991\7") + buf.write("Z\2\2\u098e\u098f\7\32\2\2\u098f\u0990\7\u00fa\2\2\u0990") + buf.write("\u0992\7\33\2\2\u0991\u098e\3\2\2\2\u0991\u0992\3\2\2") + buf.write("\2\u0992\u099a\3\2\2\2\u0993\u0997\7\u00fb\2\2\u0994\u0995") + buf.write("\7\32\2\2\u0995\u0996\7\u00fa\2\2\u0996\u0998\7\33\2\2") + buf.write("\u0997\u0994\3\2\2\2\u0997\u0998\3\2\2\2\u0998\u099a\3") + buf.write("\2\2\2\u0999\u095d\3\2\2\2\u0999\u0963\3\2\2\2\u0999\u0969") + buf.write("\3\2\2\2\u0999\u096f\3\2\2\2\u0999\u0975\3\2\2\2\u0999") + buf.write("\u097b\3\2\2\2\u0999\u0981\3\2\2\2\u0999\u0987\3\2\2\2") + buf.write("\u0999\u098d\3\2\2\2\u0999\u0993\3\2\2\2\u099a\u099e\3") + buf.write("\2\2\2\u099b\u099d\5\u011e\u0090\2\u099c\u099b\3\2\2\2") + buf.write("\u099d\u09a0\3\2\2\2\u099e\u099c\3\2\2\2\u099e\u099f\3") + buf.write("\2\2\2\u099f\u09a2\3\2\2\2\u09a0\u099e\3\2\2\2\u09a1\u095a") + buf.write("\3\2\2\2\u09a1\u09a2\3\2\2\2\u09a2\u09ab\3\2\2\2\u09a3") + buf.write("\u09a7\7!\2\2\u09a4\u09a6\5\u011c\u008f\2\u09a5\u09a4") + buf.write("\3\2\2\2\u09a6\u09a9\3\2\2\2\u09a7\u09a5\3\2\2\2\u09a7") + buf.write("\u09a8\3\2\2\2\u09a8\u09aa\3\2\2\2\u09a9\u09a7\3\2\2\2") + buf.write("\u09aa\u09ac\7\u00a8\2\2\u09ab\u09a3\3\2\2\2\u09ab\u09ac") + buf.write("\3\2\2\2\u09ac\u09ad\3\2\2\2\u09ad\u09ae\7 \2\2\u09ae") + buf.write("\u011d\3\2\2\2\u09af\u09b0\7!\2\2\u09b0\u09b4\7\u00aa") + buf.write("\2\2\u09b1\u09b2\7\32\2\2\u09b2\u09b3\7\u00fa\2\2\u09b3") + buf.write("\u09b5\7\33\2\2\u09b4\u09b1\3\2\2\2\u09b4\u09b5\3\2\2") + buf.write("\2\u09b5\u09ba\3\2\2\2\u09b6\u09b7\7\34\2\2\u09b7\u09b9") + buf.write("\5\u015c\u00af\2\u09b8\u09b6\3\2\2\2\u09b9\u09bc\3\2\2") + buf.write("\2\u09ba\u09b8\3\2\2\2\u09ba\u09bb\3\2\2\2\u09bb\u09bd") + buf.write("\3\2\2\2\u09bc\u09ba\3\2\2\2\u09bd\u09be\7\b\2\2\u09be") + buf.write("\u09bf\7\u00fa\2\2\u09bf\u011f\3\2\2\2\u09c0\u09c1\5\u0122") + buf.write("\u0092\2\u09c1\u09c2\7 \2\2\u09c2\u0121\3\2\2\2\u09c3") + buf.write("\u09c4\7\u00ab\2\2\u09c4\u0123\3\2\2\2\u09c5\u09ca\5\u0128") + buf.write("\u0095\2\u09c6\u09c7\7\u00dc\2\2\u09c7\u09c9\5\u0128\u0095") + buf.write("\2\u09c8\u09c6\3\2\2\2\u09c9\u09cc\3\2\2\2\u09ca\u09c8") + buf.write("\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb\u0125\3\2\2\2\u09cc") + buf.write("\u09ca\3\2\2\2\u09cd\u09d2\5\u0128\u0095\2\u09ce\u09cf") + buf.write("\7\u00dc\2\2\u09cf\u09d1\5\u0128\u0095\2\u09d0\u09ce\3") + buf.write("\2\2\2\u09d1\u09d4\3\2\2\2\u09d2\u09d0\3\2\2\2\u09d2\u09d3") + buf.write("\3\2\2\2\u09d3\u0127\3\2\2\2\u09d4\u09d2\3\2\2\2\u09d5") + buf.write("\u09da\5\u012a\u0096\2\u09d6\u09d7\7\u00db\2\2\u09d7\u09d9") + buf.write("\5\u012a\u0096\2\u09d8\u09d6\3\2\2\2\u09d9\u09dc\3\2\2") + buf.write("\2\u09da\u09d8\3\2\2\2\u09da\u09db\3\2\2\2\u09db\u0129") + buf.write("\3\2\2\2\u09dc\u09da\3\2\2\2\u09dd\u09e2\5\u012c\u0097") + buf.write("\2\u09de\u09df\7(\2\2\u09df\u09e1\5\u012c\u0097\2\u09e0") + buf.write("\u09de\3\2\2\2\u09e1\u09e4\3\2\2\2\u09e2\u09e0\3\2\2\2") + buf.write("\u09e2\u09e3\3\2\2\2\u09e3\u012b\3\2\2\2\u09e4\u09e2\3") + buf.write("\2\2\2\u09e5\u09ea\5\u012e\u0098\2\u09e6\u09e7\7)\2\2") + buf.write("\u09e7\u09e9\5\u012e\u0098\2\u09e8\u09e6\3\2\2\2\u09e9") + buf.write("\u09ec\3\2\2\2\u09ea\u09e8\3\2\2\2\u09ea\u09eb\3\2\2\2") + buf.write("\u09eb\u012d\3\2\2\2\u09ec\u09ea\3\2\2\2\u09ed\u09f1\5") + buf.write("\u0132\u009a\2\u09ee\u09f0\5\u0130\u0099\2\u09ef\u09ee") + buf.write("\3\2\2\2\u09f0\u09f3\3\2\2\2\u09f1\u09ef\3\2\2\2\u09f1") + buf.write("\u09f2\3\2\2\2\u09f2\u012f\3\2\2\2\u09f3\u09f1\3\2\2\2") + buf.write("\u09f4\u09f5\7\"\2\2\u09f5\u09f9\5\u0132\u009a\2\u09f6") + buf.write("\u09f7\7#\2\2\u09f7\u09f9\5\u0132\u009a\2\u09f8\u09f4") + buf.write("\3\2\2\2\u09f8\u09f6\3\2\2\2\u09f9\u0131\3\2\2\2\u09fa") + buf.write("\u09fe\5\u0136\u009c\2\u09fb\u09fd\5\u0134\u009b\2\u09fc") + buf.write("\u09fb\3\2\2\2\u09fd\u0a00\3\2\2\2\u09fe\u09fc\3\2\2\2") + buf.write("\u09fe\u09ff\3\2\2\2\u09ff\u0133\3\2\2\2\u0a00\u09fe\3") + buf.write("\2\2\2\u0a01\u0a02\7%\2\2\u0a02\u0a0a\5\u0136\u009c\2") + buf.write("\u0a03\u0a04\7$\2\2\u0a04\u0a0a\5\u0136\u009c\2\u0a05") + buf.write("\u0a06\7\'\2\2\u0a06\u0a0a\5\u0136\u009c\2\u0a07\u0a08") + buf.write("\7&\2\2\u0a08\u0a0a\5\u0136\u009c\2\u0a09\u0a01\3\2\2") + buf.write("\2\u0a09\u0a03\3\2\2\2\u0a09\u0a05\3\2\2\2\u0a09\u0a07") + buf.write("\3\2\2\2\u0a0a\u0135\3\2\2\2\u0a0b\u0a0f\5\u013a\u009e") + buf.write("\2\u0a0c\u0a0e\5\u0138\u009d\2\u0a0d\u0a0c\3\2\2\2\u0a0e") + buf.write("\u0a11\3\2\2\2\u0a0f\u0a0d\3\2\2\2\u0a0f\u0a10\3\2\2\2") + buf.write("\u0a10\u0137\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a12\u0a13\7") + buf.write("\f\2\2\u0a13\u0a17\5\u013a\u009e\2\u0a14\u0a15\7\r\2\2") + buf.write("\u0a15\u0a17\5\u013a\u009e\2\u0a16\u0a12\3\2\2\2\u0a16") + buf.write("\u0a14\3\2\2\2\u0a17\u0139\3\2\2\2\u0a18\u0a1c\5\u013e") + buf.write("\u00a0\2\u0a19\u0a1b\5\u013c\u009f\2\u0a1a\u0a19\3\2\2") + buf.write("\2\u0a1b\u0a1e\3\2\2\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1d") + buf.write("\3\2\2\2\u0a1d\u013b\3\2\2\2\u0a1e\u0a1c\3\2\2\2\u0a1f") + buf.write("\u0a20\7\16\2\2\u0a20\u0a24\5\u013e\u00a0\2\u0a21\u0a22") + buf.write("\7\35\2\2\u0a22\u0a24\5\u013e\u00a0\2\u0a23\u0a1f\3\2") + buf.write("\2\2\u0a23\u0a21\3\2\2\2\u0a24\u013d\3\2\2\2\u0a25\u0a29") + buf.write("\5\u0142\u00a2\2\u0a26\u0a28\5\u0140\u00a1\2\u0a27\u0a26") + buf.write("\3\2\2\2\u0a28\u0a2b\3\2\2\2\u0a29\u0a27\3\2\2\2\u0a29") + buf.write("\u0a2a\3\2\2\2\u0a2a\u013f\3\2\2\2\u0a2b\u0a29\3\2\2\2") + buf.write("\u0a2c\u0a2d\7\17\2\2\u0a2d\u0a33\5\u0142\u00a2\2\u0a2e") + buf.write("\u0a2f\7\37\2\2\u0a2f\u0a33\5\u0142\u00a2\2\u0a30\u0a31") + buf.write("\7\20\2\2\u0a31\u0a33\5\u0142\u00a2\2\u0a32\u0a2c\3\2") + buf.write("\2\2\u0a32\u0a2e\3\2\2\2\u0a32\u0a30\3\2\2\2\u0a33\u0141") + buf.write("\3\2\2\2\u0a34\u0a35\7\30\2\2\u0a35\u0a36\t\n\2\2\u0a36") + buf.write("\u0a38\7\31\2\2\u0a37\u0a34\3\2\2\2\u0a38\u0a3b\3\2\2") + buf.write("\2\u0a39\u0a37\3\2\2\2\u0a39\u0a3a\3\2\2\2\u0a3a\u0a3c") + buf.write("\3\2\2\2\u0a3b\u0a39\3\2\2\2\u0a3c\u0a3d\5\u0144\u00a3") + buf.write("\2\u0a3d\u0143\3\2\2\2\u0a3e\u0a4b\5\u0146\u00a4\2\u0a3f") + buf.write("\u0a4b\5\u0148\u00a5\2\u0a40\u0a4b\5\u014a\u00a6\2\u0a41") + buf.write("\u0a4b\5\u014c\u00a7\2\u0a42\u0a4b\5\u014e\u00a8\2\u0a43") + buf.write("\u0a4b\5\u016c\u00b7\2\u0a44\u0a4b\5\u016e\u00b8\2\u0a45") + buf.write("\u0a4b\5\u0184\u00c3\2\u0a46\u0a4b\5\u0194\u00cb\2\u0a47") + buf.write("\u0a48\7\u00dd\2\2\u0a48\u0a4b\5\u0144\u00a3\2\u0a49\u0a4b") + buf.write("\5\u014a\u00a6\2\u0a4a\u0a3e\3\2\2\2\u0a4a\u0a3f\3\2\2") + buf.write("\2\u0a4a\u0a40\3\2\2\2\u0a4a\u0a41\3\2\2\2\u0a4a\u0a42") + buf.write("\3\2\2\2\u0a4a\u0a43\3\2\2\2\u0a4a\u0a44\3\2\2\2\u0a4a") + buf.write("\u0a45\3\2\2\2\u0a4a\u0a46\3\2\2\2\u0a4a\u0a47\3\2\2\2") + buf.write("\u0a4a\u0a49\3\2\2\2\u0a4b\u0145\3\2\2\2\u0a4c\u0a4d\7") + buf.write("\u00e7\2\2\u0a4d\u0a4e\7\30\2\2\u0a4e\u0a4f\5\u0126\u0094") + buf.write("\2\u0a4f\u0a50\7!\2\2\u0a50\u0a51\5\u0126\u0094\2\u0a51") + buf.write("\u0a52\7\31\2\2\u0a52\u0147\3\2\2\2\u0a53\u0a54\7\u00e5") + buf.write("\2\2\u0a54\u0a55\7\30\2\2\u0a55\u0a56\5\u0126\u0094\2") + buf.write("\u0a56\u0a57\7!\2\2\u0a57\u0a58\5\u0126\u0094\2\u0a58") + buf.write("\u0a59\7\31\2\2\u0a59\u0149\3\2\2\2\u0a5a\u0a5b\7\u00e6") + buf.write("\2\2\u0a5b\u0a5c\7\30\2\2\u0a5c\u0a5d\5\u0126\u0094\2") + buf.write("\u0a5d\u0a5e\7!\2\2\u0a5e\u0a5f\5\u0126\u0094\2\u0a5f") + buf.write("\u0a60\7!\2\2\u0a60\u0a61\5L\'\2\u0a61\u0a62\7\31\2\2") + buf.write("\u0a62\u014b\3\2\2\2\u0a63\u0a64\7\30\2\2\u0a64\u0a65") + buf.write("\5\u0126\u0094\2\u0a65\u0a66\7\31\2\2\u0a66\u014d\3\2") + buf.write("\2\2\u0a67\u0a73\5\u0150\u00a9\2\u0a68\u0a73\5\u0152\u00aa") + buf.write("\2\u0a69\u0a73\5\u0154\u00ab\2\u0a6a\u0a73\5\u0156\u00ac") + buf.write("\2\u0a6b\u0a73\5\u0158\u00ad\2\u0a6c\u0a73\5\u015e\u00b0") + buf.write("\2\u0a6d\u0a73\5\u0160\u00b1\2\u0a6e\u0a73\5\u0162\u00b2") + buf.write("\2\u0a6f\u0a73\5\u0164\u00b3\2\u0a70\u0a73\5\u0166\u00b4") + buf.write("\2\u0a71\u0a73\5\u016a\u00b6\2\u0a72\u0a67\3\2\2\2\u0a72") + buf.write("\u0a68\3\2\2\2\u0a72\u0a69\3\2\2\2\u0a72\u0a6a\3\2\2\2") + buf.write("\u0a72\u0a6b\3\2\2\2\u0a72\u0a6c\3\2\2\2\u0a72\u0a6d\3") + buf.write("\2\2\2\u0a72\u0a6e\3\2\2\2\u0a72\u0a6f\3\2\2\2\u0a72\u0a70") + buf.write("\3\2\2\2\u0a72\u0a71\3\2\2\2\u0a73\u014f\3\2\2\2\u0a74") + buf.write("\u0a75\7\u00c7\2\2\u0a75\u0151\3\2\2\2\u0a76\u0a77\7\u00c8") + buf.write("\2\2\u0a77\u0a78\7\u00c9\2\2\u0a78\u0a79\7\30\2\2\u0a79") + buf.write("\u0a7a\7\u00fa\2\2\u0a7a\u0a85\7\31\2\2\u0a7b\u0a7c\7") + buf.write("\"\2\2\u0a7c\u0a86\7\u00fa\2\2\u0a7d\u0a7e\7$\2\2\u0a7e") + buf.write("\u0a86\7\u00fa\2\2\u0a7f\u0a80\7%\2\2\u0a80\u0a86\7\u00fa") + buf.write("\2\2\u0a81\u0a82\7&\2\2\u0a82\u0a86\7\u00fa\2\2\u0a83") + buf.write("\u0a84\7\'\2\2\u0a84\u0a86\7\u00fa\2\2\u0a85\u0a7b\3\2") + buf.write("\2\2\u0a85\u0a7d\3\2\2\2\u0a85\u0a7f\3\2\2\2\u0a85\u0a81") + buf.write("\3\2\2\2\u0a85\u0a83\3\2\2\2\u0a86\u0153\3\2\2\2\u0a87") + buf.write("\u0a88\7\u00ca\2\2\u0a88\u0a93\5\u015a\u00ae\2\u0a89\u0a8a") + buf.write("\7\"\2\2\u0a8a\u0a94\7\u00fa\2\2\u0a8b\u0a8c\7$\2\2\u0a8c") + buf.write("\u0a94\7\u00fa\2\2\u0a8d\u0a8e\7%\2\2\u0a8e\u0a94\7\u00fa") + buf.write("\2\2\u0a8f\u0a90\7&\2\2\u0a90\u0a94\7\u00fa\2\2\u0a91") + buf.write("\u0a92\7\'\2\2\u0a92\u0a94\7\u00fa\2\2\u0a93\u0a89\3\2") + buf.write("\2\2\u0a93\u0a8b\3\2\2\2\u0a93\u0a8d\3\2\2\2\u0a93\u0a8f") + buf.write("\3\2\2\2\u0a93\u0a91\3\2\2\2\u0a94\u0155\3\2\2\2\u0a95") + buf.write("\u0a96\7\u00cb\2\2\u0a96\u0aa1\5\u015a\u00ae\2\u0a97\u0a98") + buf.write("\7\"\2\2\u0a98\u0aa2\5\u015a\u00ae\2\u0a99\u0a9a\7$\2") + buf.write("\2\u0a9a\u0aa2\5\u015a\u00ae\2\u0a9b\u0a9c\7%\2\2\u0a9c") + buf.write("\u0aa2\5\u015a\u00ae\2\u0a9d\u0a9e\7&\2\2\u0a9e\u0aa2") + buf.write("\5\u015a\u00ae\2\u0a9f\u0aa0\7\'\2\2\u0aa0\u0aa2\5\u015a") + buf.write("\u00ae\2\u0aa1\u0a97\3\2\2\2\u0aa1\u0a99\3\2\2\2\u0aa1") + buf.write("\u0a9b\3\2\2\2\u0aa1\u0a9d\3\2\2\2\u0aa1\u0a9f\3\2\2\2") + buf.write("\u0aa2\u0157\3\2\2\2\u0aa3\u0aa4\7\u00cc\2\2\u0aa4\u0aa5") + buf.write("\5\u015a\u00ae\2\u0aa5\u0aa7\7\"\2\2\u0aa6\u0aa8\7\u00fa") + buf.write("\2\2\u0aa7\u0aa6\3\2\2\2\u0aa8\u0aa9\3\2\2\2\u0aa9\u0aa7") + buf.write("\3\2\2\2\u0aa9\u0aaa\3\2\2\2\u0aaa\u0159\3\2\2\2\u0aab") + buf.write("\u0aac\7\u00fb\2\2\u0aac\u0aad\7\32\2\2\u0aad\u0aae\7") + buf.write("\u00fa\2\2\u0aae\u0ab8\7\33\2\2\u0aaf\u0ab4\7\u00fb\2") + buf.write("\2\u0ab0\u0ab1\7\34\2\2\u0ab1\u0ab3\5\u015c\u00af\2\u0ab2") + buf.write("\u0ab0\3\2\2\2\u0ab3\u0ab6\3\2\2\2\u0ab4\u0ab2\3\2\2\2") + buf.write("\u0ab4\u0ab5\3\2\2\2\u0ab5\u0ab8\3\2\2\2\u0ab6\u0ab4\3") + buf.write("\2\2\2\u0ab7\u0aab\3\2\2\2\u0ab7\u0aaf\3\2\2\2\u0ab8\u015b") + buf.write("\3\2\2\2\u0ab9\u0abd\7\u00fb\2\2\u0aba\u0abb\7\32\2\2") + buf.write("\u0abb\u0abc\7\u00fa\2\2\u0abc\u0abe\7\33\2\2\u0abd\u0aba") + buf.write("\3\2\2\2\u0abd\u0abe\3\2\2\2\u0abe\u015d\3\2\2\2\u0abf") + buf.write("\u0ac0\7\u00cd\2\2\u0ac0\u0ac1\7\30\2\2\u0ac1\u0ac2\t") + buf.write("\13\2\2\u0ac2\u0ac3\7\31\2\2\u0ac3\u015f\3\2\2\2\u0ac4") + buf.write("\u0ac5\7\u00ce\2\2\u0ac5\u0ac6\7\30\2\2\u0ac6\u0ac7\7") + buf.write("\u00fb\2\2\u0ac7\u0ac8\7\31\2\2\u0ac8\u0161\3\2\2\2\u0ac9") + buf.write("\u0aca\7\u00cf\2\2\u0aca\u0ad0\7\30\2\2\u0acb\u0acc\7") + buf.write("\u00ec\2\2\u0acc\u0acd\7\30\2\2\u0acd\u0ace\7\u00fa\2") + buf.write("\2\u0ace\u0ad1\7\31\2\2\u0acf\u0ad1\7\u00fa\2\2\u0ad0") + buf.write("\u0acb\3\2\2\2\u0ad0\u0acf\3\2\2\2\u0ad1\u0ad2\3\2\2\2") + buf.write("\u0ad2\u0ad3\7\31\2\2\u0ad3\u0163\3\2\2\2\u0ad4\u0ad5") + buf.write("\7\u00d0\2\2\u0ad5\u0165\3\2\2\2\u0ad6\u0ad7\7\u00d1\2") + buf.write("\2\u0ad7\u0ad8\7\30\2\2\u0ad8\u0ad9\5L\'\2\u0ad9\u0ada") + buf.write("\7\31\2\2\u0ada\u0167\3\2\2\2\u0adb\u0adc\t\f\2\2\u0adc") + buf.write("\u0169\3\2\2\2\u0add\u0ade\7\u00d2\2\2\u0ade\u0adf\7\30") + buf.write("\2\2\u0adf\u0ae4\5X-\2\u0ae0\u0ae1\7(\2\2\u0ae1\u0ae2") + buf.write("\7@\2\2\u0ae2\u0ae3\7\b\2\2\u0ae3\u0ae5\5\u0168\u00b5") + buf.write("\2\u0ae4\u0ae0\3\2\2\2\u0ae4\u0ae5\3\2\2\2\u0ae5\u0ae6") + buf.write("\3\2\2\2\u0ae6\u0ae7\7\31\2\2\u0ae7\u016b\3\2\2\2\u0ae8") + buf.write("\u0ae9\t\r\2\2\u0ae9\u016d\3\2\2\2\u0aea\u0af5\5\u0170") + buf.write("\u00b9\2\u0aeb\u0af5\5\u0172\u00ba\2\u0aec\u0af5\5\u0174") + buf.write("\u00bb\2\u0aed\u0af5\5\u0176\u00bc\2\u0aee\u0af5\5\u0178") + buf.write("\u00bd\2\u0aef\u0af5\5\u017a\u00be\2\u0af0\u0af5\5\u017c") + buf.write("\u00bf\2\u0af1\u0af5\5\u017e\u00c0\2\u0af2\u0af5\5\u0180") + buf.write("\u00c1\2\u0af3\u0af5\5\u0182\u00c2\2\u0af4\u0aea\3\2\2") + buf.write("\2\u0af4\u0aeb\3\2\2\2\u0af4\u0aec\3\2\2\2\u0af4\u0aed") + buf.write("\3\2\2\2\u0af4\u0aee\3\2\2\2\u0af4\u0aef\3\2\2\2\u0af4") + buf.write("\u0af0\3\2\2\2\u0af4\u0af1\3\2\2\2\u0af4\u0af2\3\2\2\2") + buf.write("\u0af4\u0af3\3\2\2\2\u0af5\u016f\3\2\2\2\u0af6\u0af7\7") + buf.write("\u00da\2\2\u0af7\u0af8\7\30\2\2\u0af8\u0af9\5\u0126\u0094") + buf.write("\2\u0af9\u0afa\7\31\2\2\u0afa\u0171\3\2\2\2\u0afb\u0afc") + buf.write("\7\u00df\2\2\u0afc\u0afd\7\30\2\2\u0afd\u0afe\5\u0126") + buf.write("\u0094\2\u0afe\u0aff\7\31\2\2\u0aff\u0173\3\2\2\2\u0b00") + buf.write("\u0b01\7\u00e8\2\2\u0b01\u0b09\7\30\2\2\u0b02\u0b03\7") + buf.write("*\2\2\u0b03\u0b04\7\b\2\2\u0b04\u0b05\7\u00ec\2\2\u0b05") + buf.write("\u0b06\7\30\2\2\u0b06\u0b07\7\u00fa\2\2\u0b07\u0b08\7") + buf.write("\31\2\2\u0b08\u0b0a\7!\2\2\u0b09\u0b02\3\2\2\2\u0b09\u0b0a") + buf.write("\3\2\2\2\u0b0a\u0b10\3\2\2\2\u0b0b\u0b0c\7[\2\2\u0b0c") + buf.write("\u0b0d\7\b\2\2\u0b0d\u0b0e\5L\'\2\u0b0e\u0b0f\7!\2\2\u0b0f") + buf.write("\u0b11\3\2\2\2\u0b10\u0b0b\3\2\2\2\u0b10\u0b11\3\2\2\2") + buf.write("\u0b11\u0b12\3\2\2\2\u0b12\u0b13\5\u0126\u0094\2\u0b13") + buf.write("\u0b14\7\31\2\2\u0b14\u0175\3\2\2\2\u0b15\u0b16\7\u00e9") + buf.write("\2\2\u0b16\u0b17\7\30\2\2\u0b17\u0b18\5\u0126\u0094\2") + buf.write("\u0b18\u0b19\7\31\2\2\u0b19\u0177\3\2\2\2\u0b1a\u0b1b") + buf.write("\7\u00e0\2\2\u0b1b\u0b1c\7\30\2\2\u0b1c\u0b1d\5\u0126") + buf.write("\u0094\2\u0b1d\u0b1e\7\31\2\2\u0b1e\u0179\3\2\2\2\u0b1f") + buf.write("\u0b24\7\u00e1\2\2\u0b20\u0b21\7\21\2\2\u0b21\u0b22\7") + buf.write("\b\2\2\u0b22\u0b23\7\u00fa\2\2\u0b23\u0b25\7!\2\2\u0b24") + buf.write("\u0b20\3\2\2\2\u0b24\u0b25\3\2\2\2\u0b25\u0b26\3\2\2\2") + buf.write("\u0b26\u0b27\7\30\2\2\u0b27\u0b28\5\u0126\u0094\2\u0b28") + buf.write("\u0b29\7\31\2\2\u0b29\u017b\3\2\2\2\u0b2a\u0b2b\7\u00e2") + buf.write("\2\2\u0b2b\u0b2c\7\30\2\2\u0b2c\u0b2d\5\u0126\u0094\2") + buf.write("\u0b2d\u0b2e\7\31\2\2\u0b2e\u017d\3\2\2\2\u0b2f\u0b30") + buf.write("\7\u00e3\2\2\u0b30\u0b31\7\30\2\2\u0b31\u0b32\5\u0126") + buf.write("\u0094\2\u0b32\u0b33\7\31\2\2\u0b33\u017f\3\2\2\2\u0b34") + buf.write("\u0b35\7\u00e4\2\2\u0b35\u0b36\7\30\2\2\u0b36\u0b37\5") + buf.write("\u0126\u0094\2\u0b37\u0b38\7\31\2\2\u0b38\u0181\3\2\2") + buf.write("\2\u0b39\u0b3a\7\u00de\2\2\u0b3a\u0b3b\7\30\2\2\u0b3b") + buf.write("\u0b40\5X-\2\u0b3c\u0b3d\7(\2\2\u0b3d\u0b3e\7@\2\2\u0b3e") + buf.write("\u0b3f\7\b\2\2\u0b3f\u0b41\5\u0168\u00b5\2\u0b40\u0b3c") + buf.write("\3\2\2\2\u0b40\u0b41\3\2\2\2\u0b41\u0b42\3\2\2\2\u0b42") + buf.write("\u0b43\7!\2\2\u0b43\u0b44\5\u0126\u0094\2\u0b44\u0b45") + buf.write("\7\31\2\2\u0b45\u0183\3\2\2\2\u0b46\u0b4c\5\u0186\u00c4") + buf.write("\2\u0b47\u0b4c\5\u0188\u00c5\2\u0b48\u0b4c\5\u018c\u00c7") + buf.write("\2\u0b49\u0b4c\5\u018e\u00c8\2\u0b4a\u0b4c\5\u0190\u00c9") + buf.write("\2\u0b4b\u0b46\3\2\2\2\u0b4b\u0b47\3\2\2\2\u0b4b\u0b48") + buf.write("\3\2\2\2\u0b4b\u0b49\3\2\2\2\u0b4b\u0b4a\3\2\2\2\u0b4c") + buf.write("\u0185\3\2\2\2\u0b4d\u0b4e\7\u00c2\2\2\u0b4e\u0b4f\7\30") + buf.write("\2\2\u0b4f\u0b50\5\u0126\u0094\2\u0b50\u0b51\7\22\2\2") + buf.write("\u0b51\u0b52\5\u0126\u0094\2\u0b52\u0b53\7\36\2\2\u0b53") + buf.write("\u0b54\5\u0126\u0094\2\u0b54\u0b55\7\31\2\2\u0b55\u0187") + buf.write("\3\2\2\2\u0b56\u0b57\7\u00c3\2\2\u0b57\u0b58\7\30\2\2") + buf.write("\u0b58\u0b5d\5\u018a\u00c6\2\u0b59\u0b5a\7(\2\2\u0b5a") + buf.write("\u0b5c\5\u018a\u00c6\2\u0b5b\u0b59\3\2\2\2\u0b5c\u0b5f") + buf.write("\3\2\2\2\u0b5d\u0b5b\3\2\2\2\u0b5d\u0b5e\3\2\2\2\u0b5e") + buf.write("\u0b60\3\2\2\2\u0b5f\u0b5d\3\2\2\2\u0b60\u0b61\7!\2\2") + buf.write("\u0b61\u0b62\5\u0126\u0094\2\u0b62\u0b63\7!\2\2\u0b63") + buf.write("\u0b64\5\u0126\u0094\2\u0b64\u0b65\7!\2\2\u0b65\u0b66") + buf.write("\5\u0126\u0094\2\u0b66\u0b67\7\31\2\2\u0b67\u0189\3\2") + buf.write("\2\2\u0b68\u0b69\t\16\2\2\u0b69\u018b\3\2\2\2\u0b6a\u0b6b") + buf.write("\7\u00c4\2\2\u0b6b\u0b6c\7\30\2\2\u0b6c\u0b6d\5\u0126") + buf.write("\u0094\2\u0b6d\u0b6e\7!\2\2\u0b6e\u0b6f\5\u0126\u0094") + buf.write("\2\u0b6f\u0b70\7!\2\2\u0b70\u0b71\5\u0126\u0094\2\u0b71") + buf.write("\u0b72\7\31\2\2\u0b72\u018d\3\2\2\2\u0b73\u0b74\7\u00c5") + buf.write("\2\2\u0b74\u0b75\7\30\2\2\u0b75\u0b76\5\u0126\u0094\2") + buf.write("\u0b76\u0b77\7!\2\2\u0b77\u0b78\5\u0126\u0094\2\u0b78") + buf.write("\u0b79\7!\2\2\u0b79\u0b7a\5\u0126\u0094\2\u0b7a\u0b7b") + buf.write("\7\31\2\2\u0b7b\u018f\3\2\2\2\u0b7c\u0b7d\7\u00c6\2\2") + buf.write("\u0b7d\u0b7e\7\30\2\2\u0b7e\u0b7f\7@\2\2\u0b7f\u0b80\7") + buf.write("\b\2\2\u0b80\u0b85\5\u0192\u00ca\2\u0b81\u0b82\7(\2\2") + buf.write("\u0b82\u0b84\5\u0192\u00ca\2\u0b83\u0b81\3\2\2\2\u0b84") + buf.write("\u0b87\3\2\2\2\u0b85\u0b83\3\2\2\2\u0b85\u0b86\3\2\2\2") + buf.write("\u0b86\u0b88\3\2\2\2\u0b87\u0b85\3\2\2\2\u0b88\u0b89\7") + buf.write("!\2\2\u0b89\u0b8a\5\u0126\u0094\2\u0b8a\u0b8b\7!\2\2\u0b8b") + buf.write("\u0b8c\5\u0126\u0094\2\u0b8c\u0b8d\7!\2\2\u0b8d\u0b8e") + buf.write("\5\u0126\u0094\2\u0b8e\u0b8f\7\31\2\2\u0b8f\u0191\3\2") + buf.write("\2\2\u0b90\u0b91\t\17\2\2\u0b91\u0193\3\2\2\2\u0b92\u0b93") + buf.write("\7\u00ea\2\2\u0b93\u0b94\7\30\2\2\u0b94\u0b95\5\u0126") + buf.write("\u0094\2\u0b95\u0b9d\7\36\2\2\u0b96\u0b97\5\u0124\u0093") + buf.write("\2\u0b97\u0b98\7!\2\2\u0b98\u0b99\5\u0124\u0093\2\u0b99") + buf.write("\u0b9a\7 \2\2\u0b9a\u0b9c\3\2\2\2\u0b9b\u0b96\3\2\2\2") + buf.write("\u0b9c\u0b9f\3\2\2\2\u0b9d\u0b9b\3\2\2\2\u0b9d\u0b9e\3") + buf.write("\2\2\2\u0b9e\u0ba0\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0ba0\u0ba1") + buf.write("\7\31\2\2\u0ba1\u0195\3\2\2\2\u00f0\u0199\u019b\u01a5") + buf.write("\u01a9\u01ac\u01b4\u01b9\u01bd\u01c0\u01c6\u01cb\u01cf") + buf.write("\u01d2\u01d8\u01ea\u01ec\u01f4\u01fd\u0206\u020f\u0218") + buf.write("\u0221\u022a\u0233\u023c\u0245\u024b\u0253\u025b\u0263") + buf.write("\u0281\u0288\u028f\u0298\u029c\u02a0\u02a7\u02b1\u02be") + buf.write("\u02cd\u02e2\u02e8\u0304\u030a\u0313\u0326\u0336\u0341") + buf.write("\u0372\u0382\u0389\u038f\u03a7\u03b2\u03b5\u03b8\u03df") + buf.write("\u03e3\u03f0\u03f7\u0409\u041e\u0433\u0439\u044f\u045c") + buf.write("\u0460\u0465\u046b\u046e\u0472\u0476\u047d\u0497\u04a1") + buf.write("\u04a9\u04ad\u04b3\u04b7\u04e5\u04e9\u04f0\u04f6\u04fa") + buf.write("\u0503\u0508\u0514\u051f\u052c\u053d\u0542\u0547\u0558") + buf.write("\u055d\u0562\u056a\u058a\u058f\u0594\u059e\u05a8\u05b4") + buf.write("\u05b9\u05be\u05ca\u05cf\u05d4\u05de\u05e4\u05ff\u0605") + buf.write("\u060f\u061d\u062a\u062f\u0633\u063e\u0644\u064f\u0658") + buf.write("\u0662\u0674\u0679\u067d\u0688\u068e\u0698\u069f\u06a7") + buf.write("\u06ae\u06ba\u06c5\u06c8\u06d3\u06d8\u06e2\u06e8\u06fb") + buf.write("\u0701\u070b\u0711\u071f\u072a\u072f\u0738\u073f\u074a") + buf.write("\u0751\u075b\u07a6\u07ab\u07ae\u07bf\u07c5\u07cc\u07d9") + buf.write("\u0824\u0829\u082c\u083d\u0843\u084a\u0853\u0864\u086a") + buf.write("\u0872\u0880\u0885\u0892\u0897\u08a4\u08a9\u08b0\u08be") + buf.write("\u08c3\u08ca\u08df\u08e4\u08ed\u090e\u092e\u0931\u0937") + buf.write("\u0941\u0954\u0961\u0967\u096d\u0973\u0979\u097f\u0985") + buf.write("\u098b\u0991\u0997\u0999\u099e\u09a1\u09a7\u09ab\u09b4") + buf.write("\u09ba\u09ca\u09d2\u09da\u09e2\u09ea\u09f1\u09f8\u09fe") + buf.write("\u0a09\u0a0f\u0a16\u0a1c\u0a23\u0a29\u0a32\u0a39\u0a4a") + buf.write("\u0a72\u0a85\u0a93\u0aa1\u0aa9\u0ab4\u0ab7\u0abd\u0ad0") + buf.write("\u0ae4\u0af4\u0b09\u0b10\u0b24\u0b40\u0b4b\u0b5d\u0b85") + buf.write("\u0b9d") + return buf.getvalue() + + +class VfrSyntaxParser ( Parser ): + + grammarFileName = "VfrSyntax.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "<INVALID>", "'show'", "'push'", "'pop'", "'#pragma'", + "'pack'", "'='", "'IMAGE_TOKEN'", "'HORIZONTAL'", "'MULTI_LINE'", + "'<<'", "'>>'", "'+'", "'*'", "'%'", "'format'", "'?'", + "'#define'", "'#include'", "'formpkgtype'", "'{'", + "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'", + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", + "'>='", "'>'", "'|'", "'&'", "'devicepath'", "'formset'", + "'formsetid'", "'endformset'", "'title'", "'formid'", + "'oneof'", "'endoneof'", "'prompt'", "'orderedlist'", + "'maxcontainers'", "'endlist'", "'endform'", "'form'", + "'formmap'", "'maptitle'", "'mapguid'", "'subtitle'", + "'endsubtitle'", "'help'", "'text'", "'option'", "'flags'", + "'date'", "'enddate'", "'year'", "'month'", "'day'", + "'time'", "'endtime'", "'hour'", "'minute'", "'second'", + "'grayoutif'", "'label'", "'timeout'", "'inventory'", + "'_NON_NV_DATA_MAP'", "'struct'", "'union'", "'BOOLEAN'", + "'UINT64'", "'UINT32'", "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", + "'EFI_HII_DATE'", "'EFI_HII_TIME'", "'EFI_HII_REF'", + "'guid'", "'checkbox'", "'endcheckbox'", "'numeric'", + "'endnumeric'", "'minimum'", "'maximum'", "'step'", + "'default'", "'password'", "'endpassword'", "'string'", + "'endstring'", "'minsize'", "'maxsize'", "'encoding'", + "'suppressif'", "'disableif'", "'hidden'", "'goto'", + "'formsetguid'", "'inconsistentif'", "'warningif'", + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'", + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'", + "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'", + "'LATE_CHECK'", "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", + "'class'", "'subclass'", "'classguid'", "'typedef'", + "'restore'", "'save'", "'defaults'", "'banner'", "'align'", + "'left'", "'right'", "'center'", "'line'", "'name'", + "'varid'", "'question'", "'questionid'", "'image'", + "'locked'", "'rule'", "'endrule'", "'value'", "'read'", + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'", + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'", + "'namevaluevarstore'", "'action'", "'config'", "'endaction'", + "'refresh'", "'interval'", "'varstoredevice'", "'guidop'", + "'endguidop'", "'datatype'", "'data'", "'modal'", "'NON_DEVICE'", + "'DISK_DEVICE'", "'VIDEO_DEVICE'", "'NETWORK_DEVICE'", + "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'", + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'", + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'", + "'DAY_SUPPRESS'", "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", + "'SECOND_SUPPRESS'", "'STORAGE_NORMAL'", "'STORAGE_TIME'", + "'STORAGE_WAKEUP'", "'UNIQUE'", "'NOEMPTY'", "'cond'", + "'find'", "'mid'", "'token'", "'span'", "'dup'", "'vareqval'", + "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'", + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", + "'security'", "'get'", "'TRUE'", "'FALSE'", "'ONE'", + "'ONES'", "'ZERO'", "'UNDEFINED'", "'VERSION'", "'length'", + "'AND'", "'OR'", "'NOT'", "'set'", "'~'", "'boolval'", + "'stringval'", "'unintval'", "'toupper'", "'tolower'", + "'match'", "'match2'", "'catenate'", "'questionrefval'", + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'", + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'", + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'", + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'", + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'", + "'FIRST_NON_MATCH'" ] + + symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", + "<INVALID>", "Define", "Include", "FormPkgType", "OpenBrace", + "CloseBrace", "OpenParen", "CloseParen", "OpenBracket", + "CloseBracket", "Dot", "Negative", "Colon", "Slash", + "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual", + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd", + "DevicePath", "FormSet", "FormSetId", "EndFormSet", + "Title", "FormId", "OneOf", "EndOneOf", "Prompt", + "OrderedList", "MaxContainers", "EndList", "EndForm", + "Form", "FormMap", "MapTitle", "MapGuid", "Subtitle", + "EndSubtitle", "Help", "Text", "Option", "FLAGS", + "Date", "EndDate", "Year", "Month", "Day", "Time", + "EndTime", "Hour", "Minute", "Second", "GrayOutIf", + "Label", "Timeout", "Inventory", "NonNvDataMap", "Struct", + "Union", "Boolean", "Uint64", "Uint32", "Uint16", + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME", + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", + "Numeric", "EndNumeric", "Minimum", "Maximum", "Step", + "Default", "Password", "EndPassword", "String", "EndString", + "MinSize", "MaxSize", "Encoding", "SuppressIf", "DisableIf", + "Hidden", "Goto", "FormSetGuid", "InconsistentIf", + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag", + "ManufacturingFlag", "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", + "InteractiveFlag", "NVAccessFlag", "ResetRequiredFlag", + "ReconnectRequiredFlag", "LateCheckFlag", "ReadOnlyFlag", + "OptionOnlyFlag", "RestStyleFlag", "Class", "Subclass", + "ClassGuid", "TypeDef", "Restore", "Save", "Defaults", + "Banner", "Align", "Left", "Right", "Center", "Line", + "Name", "VarId", "Question", "QuestionId", "Image", + "Locked", "Rule", "EndRule", "Value", "Read", "Write", + "ResetButton", "EndResetButton", "DefaultStore", "Attribute", + "Varstore", "Efivarstore", "VarSize", "NameValueVarStore", + "Action", "Config", "EndAction", "Refresh", "Interval", + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", + "Data", "Modal", "ClassNonDevice", "ClassDiskDevice", + "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice", + "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication", + "SubclassGeneralApplication", "SubclassFrontPage", + "SubclassSingleUse", "YearSupppressFlag", "MonthSuppressFlag", + "DaySuppressFlag", "HourSupppressFlag", "MinuteSuppressFlag", + "SecondSuppressFlag", "StorageNormalFlag", "StorageTimeFlag", + "StorageWakeUpFlag", "UniQueFlag", "NoEmptyFlag", + "Cond", "Find", "Mid", "Tok", "Span", "Dup", "VarEqVal", + "Var", "IdEqVal", "IdEqId", "IdEqValList", "QuestionRef", + "RuleRef", "StringRef", "PushThis", "Security", "Get", + "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero", + "Undefined", "Version", "Length", "AND", "OR", "NOT", + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal", + "ToUpper", "ToLower", "Match", "Match2", "Catenate", + "QuestionRefVal", "StringRefVal", "Map", "RefreshGuid", + "StringToken", "OptionDefault", "OptionDefaultMfg", + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour", + "NumericSizeEight", "DisPlayIntDec", "DisPlayUIntDec", + "DisPlayUIntHex", "Insensitive", "Sensitive", "LastNonMatch", + "FirstNonMatch", "Number", "StringIdentifier", "ComplexDefine", + "LineDefinition", "IncludeDefinition", "Whitespace", + "Newline", "LineComment", "Extern" ] + + RULE_vfrProgram = 0 + RULE_pragmaPackShowDef = 1 + RULE_pragmaPackStackDef = 2 + RULE_pragmaPackNumber = 3 + RULE_vfrPragmaPackDefinition = 4 + RULE_vfrDataStructDefinition = 5 + RULE_vfrDataUnionDefinition = 6 + RULE_vfrDataStructFields = 7 + RULE_dataStructField64 = 8 + RULE_dataStructField32 = 9 + RULE_dataStructField16 = 10 + RULE_dataStructField8 = 11 + RULE_dataStructFieldBool = 12 + RULE_dataStructFieldString = 13 + RULE_dataStructFieldDate = 14 + RULE_dataStructFieldTime = 15 + RULE_dataStructFieldRef = 16 + RULE_dataStructFieldUser = 17 + RULE_dataStructBitField64 = 18 + RULE_dataStructBitField32 = 19 + RULE_dataStructBitField16 = 20 + RULE_dataStructBitField8 = 21 + RULE_vfrFormSetDefinition = 22 + RULE_classguidDefinition = 23 + RULE_classDefinition = 24 + RULE_validClassNames = 25 + RULE_subclassDefinition = 26 + RULE_vfrFormSetList = 27 + RULE_vfrFormSet = 28 + RULE_vfrStatementDefaultStore = 29 + RULE_vfrStatementVarStoreLinear = 30 + RULE_vfrStatementVarStoreEfi = 31 + RULE_vfrVarStoreEfiAttr = 32 + RULE_vfrStatementVarStoreNameValue = 33 + RULE_vfrStatementDisableIfFormSet = 34 + RULE_vfrStatementSuppressIfFormSet = 35 + RULE_guidSubDefinition = 36 + RULE_guidDefinition = 37 + RULE_getStringId = 38 + RULE_vfrQuestionHeader = 39 + RULE_vfrQuestionBaseInfo = 40 + RULE_vfrStatementHeader = 41 + RULE_questionheaderFlagsField = 42 + RULE_vfrStorageVarId = 43 + RULE_vfrConstantValueField = 44 + RULE_vfrImageTag = 45 + RULE_vfrLockedTag = 46 + RULE_vfrStatementStatTag = 47 + RULE_vfrStatementStatTagList = 48 + RULE_vfrFormDefinition = 49 + RULE_vfrForm = 50 + RULE_vfrFormMapDefinition = 51 + RULE_vfrStatementImage = 52 + RULE_vfrStatementLocked = 53 + RULE_vfrStatementRules = 54 + RULE_vfrStatementStat = 55 + RULE_vfrStatementSubTitle = 56 + RULE_vfrStatementSubTitleComponent = 57 + RULE_vfrSubtitleFlags = 58 + RULE_subtitleFlagsField = 59 + RULE_vfrStatementStaticText = 60 + RULE_staticTextFlagsField = 61 + RULE_vfrStatementCrossReference = 62 + RULE_vfrStatementGoto = 63 + RULE_vfrGotoFlags = 64 + RULE_gotoFlagsField = 65 + RULE_vfrStatementResetButton = 66 + RULE_vfrStatementQuestions = 67 + RULE_vfrStatementQuestionTag = 68 + RULE_vfrStatementInconsistentIf = 69 + RULE_vfrStatementNoSubmitIf = 70 + RULE_vfrStatementDisableIfQuest = 71 + RULE_vfrStatementRefresh = 72 + RULE_vfrStatementVarstoreDevice = 73 + RULE_vfrStatementRefreshEvent = 74 + RULE_vfrStatementWarningIf = 75 + RULE_vfrStatementQuestionTagList = 76 + RULE_vfrStatementQuestionOptionTag = 77 + RULE_flagsField = 78 + RULE_vfrStatementSuppressIfQuest = 79 + RULE_vfrStatementGrayOutIfQuest = 80 + RULE_vfrStatementDefault = 81 + RULE_vfrStatementValue = 82 + RULE_vfrStatementOptions = 83 + RULE_vfrStatementOneOfOption = 84 + RULE_vfrOneOfOptionFlags = 85 + RULE_oneofoptionFlagsField = 86 + RULE_vfrStatementRead = 87 + RULE_vfrStatementWrite = 88 + RULE_vfrStatementQuestionOptionList = 89 + RULE_vfrStatementQuestionOption = 90 + RULE_vfrStatementBooleanType = 91 + RULE_vfrStatementCheckBox = 92 + RULE_vfrCheckBoxFlags = 93 + RULE_checkboxFlagsField = 94 + RULE_vfrStatementAction = 95 + RULE_vfrActionFlags = 96 + RULE_actionFlagsField = 97 + RULE_vfrStatementNumericType = 98 + RULE_vfrStatementNumeric = 99 + RULE_vfrSetMinMaxStep = 100 + RULE_vfrNumericFlags = 101 + RULE_numericFlagsField = 102 + RULE_vfrStatementOneOf = 103 + RULE_vfrOneofFlagsField = 104 + RULE_vfrStatementStringType = 105 + RULE_vfrStatementString = 106 + RULE_vfrStringFlagsField = 107 + RULE_stringFlagsField = 108 + RULE_vfrStatementPassword = 109 + RULE_vfrPasswordFlagsField = 110 + RULE_passwordFlagsField = 111 + RULE_vfrStatementOrderedList = 112 + RULE_vfrOrderedListFlags = 113 + RULE_orderedlistFlagsField = 114 + RULE_vfrStatementDate = 115 + RULE_minMaxDateStepDefault = 116 + RULE_vfrDateFlags = 117 + RULE_dateFlagsField = 118 + RULE_vfrStatementTime = 119 + RULE_minMaxTimeStepDefault = 120 + RULE_vfrTimeFlags = 121 + RULE_timeFlagsField = 122 + RULE_vfrStatementConditional = 123 + RULE_vfrStatementConditionalNew = 124 + RULE_vfrStatementSuppressIfStat = 125 + RULE_vfrStatementGrayOutIfStat = 126 + RULE_vfrStatementStatList = 127 + RULE_vfrStatementStatListOld = 128 + RULE_vfrStatementDisableIfStat = 129 + RULE_vfrStatementgrayoutIfSuppressIf = 130 + RULE_vfrStatementsuppressIfGrayOutIf = 131 + RULE_vfrStatementSuppressIfStatNew = 132 + RULE_vfrStatementGrayOutIfStatNew = 133 + RULE_vfrStatementInconsistentIfStat = 134 + RULE_vfrStatementInvalid = 135 + RULE_vfrStatementInvalidHidden = 136 + RULE_vfrStatementInvalidInventory = 137 + RULE_vfrStatementInvalidSaveRestoreDefaults = 138 + RULE_vfrStatementLabel = 139 + RULE_vfrStatementBanner = 140 + RULE_vfrStatementExtension = 141 + RULE_vfrExtensionData = 142 + RULE_vfrStatementModal = 143 + RULE_vfrModalTag = 144 + RULE_vfrStatementExpression = 145 + RULE_vfrStatementExpressionSub = 146 + RULE_andTerm = 147 + RULE_bitwiseorTerm = 148 + RULE_bitwiseandTerm = 149 + RULE_equalTerm = 150 + RULE_equalTermSupplementary = 151 + RULE_compareTerm = 152 + RULE_compareTermSupplementary = 153 + RULE_shiftTerm = 154 + RULE_shiftTermSupplementary = 155 + RULE_addMinusTerm = 156 + RULE_addMinusTermSupplementary = 157 + RULE_multdivmodTerm = 158 + RULE_multdivmodTermSupplementary = 159 + RULE_castTerm = 160 + RULE_atomTerm = 161 + RULE_vfrExpressionCatenate = 162 + RULE_vfrExpressionMatch = 163 + RULE_vfrExpressionMatch2 = 164 + RULE_vfrExpressionParen = 165 + RULE_vfrExpressionBuildInFunction = 166 + RULE_dupExp = 167 + RULE_vareqvalExp = 168 + RULE_ideqvalExp = 169 + RULE_ideqidExp = 170 + RULE_ideqvallistExp = 171 + RULE_vfrQuestionDataFieldName = 172 + RULE_arrayName = 173 + RULE_questionref1Exp = 174 + RULE_rulerefExp = 175 + RULE_stringref1Exp = 176 + RULE_pushthisExp = 177 + RULE_securityExp = 178 + RULE_numericVarStoreType = 179 + RULE_getExp = 180 + RULE_vfrExpressionConstant = 181 + RULE_vfrExpressionUnaryOp = 182 + RULE_lengthExp = 183 + RULE_bitwisenotExp = 184 + RULE_question23refExp = 185 + RULE_stringref2Exp = 186 + RULE_toboolExp = 187 + RULE_tostringExp = 188 + RULE_unintExp = 189 + RULE_toupperExp = 190 + RULE_tolwerExp = 191 + RULE_setExp = 192 + RULE_vfrExpressionTernaryOp = 193 + RULE_conditionalExp = 194 + RULE_findExp = 195 + RULE_findFormat = 196 + RULE_midExp = 197 + RULE_tokenExp = 198 + RULE_spanExp = 199 + RULE_spanFlags = 200 + RULE_vfrExpressionMap = 201 + + ruleNames = [ "vfrProgram", "pragmaPackShowDef", "pragmaPackStackDef", + "pragmaPackNumber", "vfrPragmaPackDefinition", "vfrDataStructDefinition", + "vfrDataUnionDefinition", "vfrDataStructFields", "dataStructField64", + "dataStructField32", "dataStructField16", "dataStructField8", + "dataStructFieldBool", "dataStructFieldString", "dataStructFieldDate", + "dataStructFieldTime", "dataStructFieldRef", "dataStructFieldUser", + "dataStructBitField64", "dataStructBitField32", "dataStructBitField16", + "dataStructBitField8", "vfrFormSetDefinition", "classguidDefinition", + "classDefinition", "validClassNames", "subclassDefinition", + "vfrFormSetList", "vfrFormSet", "vfrStatementDefaultStore", + "vfrStatementVarStoreLinear", "vfrStatementVarStoreEfi", + "vfrVarStoreEfiAttr", "vfrStatementVarStoreNameValue", + "vfrStatementDisableIfFormSet", "vfrStatementSuppressIfFormSet", + "guidSubDefinition", "guidDefinition", "getStringId", + "vfrQuestionHeader", "vfrQuestionBaseInfo", "vfrStatementHeader", + "questionheaderFlagsField", "vfrStorageVarId", "vfrConstantValueField", + "vfrImageTag", "vfrLockedTag", "vfrStatementStatTag", + "vfrStatementStatTagList", "vfrFormDefinition", "vfrForm", + "vfrFormMapDefinition", "vfrStatementImage", "vfrStatementLocked", + "vfrStatementRules", "vfrStatementStat", "vfrStatementSubTitle", + "vfrStatementSubTitleComponent", "vfrSubtitleFlags", + "subtitleFlagsField", "vfrStatementStaticText", "staticTextFlagsField", + "vfrStatementCrossReference", "vfrStatementGoto", "vfrGotoFlags", + "gotoFlagsField", "vfrStatementResetButton", "vfrStatementQuestions", + "vfrStatementQuestionTag", "vfrStatementInconsistentIf", + "vfrStatementNoSubmitIf", "vfrStatementDisableIfQuest", + "vfrStatementRefresh", "vfrStatementVarstoreDevice", + "vfrStatementRefreshEvent", "vfrStatementWarningIf", + "vfrStatementQuestionTagList", "vfrStatementQuestionOptionTag", + "flagsField", "vfrStatementSuppressIfQuest", "vfrStatementGrayOutIfQuest", + "vfrStatementDefault", "vfrStatementValue", "vfrStatementOptions", + "vfrStatementOneOfOption", "vfrOneOfOptionFlags", "oneofoptionFlagsField", + "vfrStatementRead", "vfrStatementWrite", "vfrStatementQuestionOptionList", + "vfrStatementQuestionOption", "vfrStatementBooleanType", + "vfrStatementCheckBox", "vfrCheckBoxFlags", "checkboxFlagsField", + "vfrStatementAction", "vfrActionFlags", "actionFlagsField", + "vfrStatementNumericType", "vfrStatementNumeric", "vfrSetMinMaxStep", + "vfrNumericFlags", "numericFlagsField", "vfrStatementOneOf", + "vfrOneofFlagsField", "vfrStatementStringType", "vfrStatementString", + "vfrStringFlagsField", "stringFlagsField", "vfrStatementPassword", + "vfrPasswordFlagsField", "passwordFlagsField", "vfrStatementOrderedList", + "vfrOrderedListFlags", "orderedlistFlagsField", "vfrStatementDate", + "minMaxDateStepDefault", "vfrDateFlags", "dateFlagsField", + "vfrStatementTime", "minMaxTimeStepDefault", "vfrTimeFlags", + "timeFlagsField", "vfrStatementConditional", "vfrStatementConditionalNew", + "vfrStatementSuppressIfStat", "vfrStatementGrayOutIfStat", + "vfrStatementStatList", "vfrStatementStatListOld", "vfrStatementDisableIfStat", + "vfrStatementgrayoutIfSuppressIf", "vfrStatementsuppressIfGrayOutIf", + "vfrStatementSuppressIfStatNew", "vfrStatementGrayOutIfStatNew", + "vfrStatementInconsistentIfStat", "vfrStatementInvalid", + "vfrStatementInvalidHidden", "vfrStatementInvalidInventory", + "vfrStatementInvalidSaveRestoreDefaults", "vfrStatementLabel", + "vfrStatementBanner", "vfrStatementExtension", "vfrExtensionData", + "vfrStatementModal", "vfrModalTag", "vfrStatementExpression", + "vfrStatementExpressionSub", "andTerm", "bitwiseorTerm", + "bitwiseandTerm", "equalTerm", "equalTermSupplementary", + "compareTerm", "compareTermSupplementary", "shiftTerm", + "shiftTermSupplementary", "addMinusTerm", "addMinusTermSupplementary", + "multdivmodTerm", "multdivmodTermSupplementary", "castTerm", + "atomTerm", "vfrExpressionCatenate", "vfrExpressionMatch", + "vfrExpressionMatch2", "vfrExpressionParen", "vfrExpressionBuildInFunction", + "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp", "ideqvallistExp", + "vfrQuestionDataFieldName", "arrayName", "questionref1Exp", + "rulerefExp", "stringref1Exp", "pushthisExp", "securityExp", + "numericVarStoreType", "getExp", "vfrExpressionConstant", + "vfrExpressionUnaryOp", "lengthExp", "bitwisenotExp", + "question23refExp", "stringref2Exp", "toboolExp", "tostringExp", + "unintExp", "toupperExp", "tolwerExp", "setExp", "vfrExpressionTernaryOp", + "conditionalExp", "findExp", "findFormat", "midExp", + "tokenExp", "spanExp", "spanFlags", "vfrExpressionMap" ] + + EOF = Token.EOF + T__0=1 + T__1=2 + T__2=3 + T__3=4 + T__4=5 + T__5=6 + T__6=7 + T__7=8 + T__8=9 + T__9=10 + T__10=11 + T__11=12 + T__12=13 + T__13=14 + T__14=15 + T__15=16 + Define=17 + Include=18 + FormPkgType=19 + OpenBrace=20 + CloseBrace=21 + OpenParen=22 + CloseParen=23 + OpenBracket=24 + CloseBracket=25 + Dot=26 + Negative=27 + Colon=28 + Slash=29 + Semicolon=30 + Comma=31 + Equal=32 + NotEqual=33 + LessEqual=34 + Less=35 + GreaterEqual=36 + Greater=37 + BitWiseOr=38 + BitWiseAnd=39 + DevicePath=40 + FormSet=41 + FormSetId=42 + EndFormSet=43 + Title=44 + FormId=45 + OneOf=46 + EndOneOf=47 + Prompt=48 + OrderedList=49 + MaxContainers=50 + EndList=51 + EndForm=52 + Form=53 + FormMap=54 + MapTitle=55 + MapGuid=56 + Subtitle=57 + EndSubtitle=58 + Help=59 + Text=60 + Option=61 + FLAGS=62 + Date=63 + EndDate=64 + Year=65 + Month=66 + Day=67 + Time=68 + EndTime=69 + Hour=70 + Minute=71 + Second=72 + GrayOutIf=73 + Label=74 + Timeout=75 + Inventory=76 + NonNvDataMap=77 + Struct=78 + Union=79 + Boolean=80 + Uint64=81 + Uint32=82 + Uint16=83 + Uint8=84 + EFI_STRING_ID=85 + EFI_HII_DATE=86 + EFI_HII_TIME=87 + EFI_HII_REF=88 + Uuid=89 + CheckBox=90 + EndCheckBox=91 + Numeric=92 + EndNumeric=93 + Minimum=94 + Maximum=95 + Step=96 + Default=97 + Password=98 + EndPassword=99 + String=100 + EndString=101 + MinSize=102 + MaxSize=103 + Encoding=104 + SuppressIf=105 + DisableIf=106 + Hidden=107 + Goto=108 + FormSetGuid=109 + InconsistentIf=110 + WarningIf=111 + NoSubmitIf=112 + EndIf=113 + Key=114 + DefaultFlag=115 + ManufacturingFlag=116 + CheckBoxDefaultFlag=117 + CheckBoxDefaultMfgFlag=118 + InteractiveFlag=119 + NVAccessFlag=120 + ResetRequiredFlag=121 + ReconnectRequiredFlag=122 + LateCheckFlag=123 + ReadOnlyFlag=124 + OptionOnlyFlag=125 + RestStyleFlag=126 + Class=127 + Subclass=128 + ClassGuid=129 + TypeDef=130 + Restore=131 + Save=132 + Defaults=133 + Banner=134 + Align=135 + Left=136 + Right=137 + Center=138 + Line=139 + Name=140 + VarId=141 + Question=142 + QuestionId=143 + Image=144 + Locked=145 + Rule=146 + EndRule=147 + Value=148 + Read=149 + Write=150 + ResetButton=151 + EndResetButton=152 + DefaultStore=153 + Attribute=154 + Varstore=155 + Efivarstore=156 + VarSize=157 + NameValueVarStore=158 + Action=159 + Config=160 + EndAction=161 + Refresh=162 + Interval=163 + VarstoreDevice=164 + GuidOp=165 + EndGuidOp=166 + DataType=167 + Data=168 + Modal=169 + ClassNonDevice=170 + ClassDiskDevice=171 + ClassVideoDevice=172 + ClassNetworkDevice=173 + ClassInputDevice=174 + ClassOnBoardDevice=175 + ClassOtherDevice=176 + SubclassSetupApplication=177 + SubclassGeneralApplication=178 + SubclassFrontPage=179 + SubclassSingleUse=180 + YearSupppressFlag=181 + MonthSuppressFlag=182 + DaySuppressFlag=183 + HourSupppressFlag=184 + MinuteSuppressFlag=185 + SecondSuppressFlag=186 + StorageNormalFlag=187 + StorageTimeFlag=188 + StorageWakeUpFlag=189 + UniQueFlag=190 + NoEmptyFlag=191 + Cond=192 + Find=193 + Mid=194 + Tok=195 + Span=196 + Dup=197 + VarEqVal=198 + Var=199 + IdEqVal=200 + IdEqId=201 + IdEqValList=202 + QuestionRef=203 + RuleRef=204 + StringRef=205 + PushThis=206 + Security=207 + Get=208 + TrueSymbol=209 + FalseSymbol=210 + One=211 + Ones=212 + Zero=213 + Undefined=214 + Version=215 + Length=216 + AND=217 + OR=218 + NOT=219 + Set=220 + BitWiseNot=221 + BoolVal=222 + StringVal=223 + UnIntVal=224 + ToUpper=225 + ToLower=226 + Match=227 + Match2=228 + Catenate=229 + QuestionRefVal=230 + StringRefVal=231 + Map=232 + RefreshGuid=233 + StringToken=234 + OptionDefault=235 + OptionDefaultMfg=236 + NumericSizeOne=237 + NumericSizeTwo=238 + NumericSizeFour=239 + NumericSizeEight=240 + DisPlayIntDec=241 + DisPlayUIntDec=242 + DisPlayUIntHex=243 + Insensitive=244 + Sensitive=245 + LastNonMatch=246 + FirstNonMatch=247 + Number=248 + StringIdentifier=249 + ComplexDefine=250 + LineDefinition=251 + IncludeDefinition=252 + Whitespace=253 + Newline=254 + LineComment=255 + Extern=256 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class VfrProgramContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vfrFormSetDefinition(self): + return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0) + + + def vfrPragmaPackDefinition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(VfrSyntaxParser.VfrPragmaPackDefinitionContext) + else: + return self.getTypedRuleContext(VfrSyntaxParser.VfrPragmaPackDefinitionContext,i) + + + def vfrDataStructDefinition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataStructDefinitionContext) + else: + return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructDefinitionContext,i) + + + def vfrDataUnionDefinition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataUnionDefinitionContext) + else: + return self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i) + + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_vfrProgram + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVfrProgram" ): + return visitor.visitVfrProgram(self) + else: + return visitor.visitChildren(self) + + + + + def vfrProgram(self): + + localctx = VfrSyntaxParser.VfrProgramContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_vfrProgram) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 409 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==VfrSyntaxParser.T__3 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (VfrSyntaxParser.Struct - 78)) | (1 << (VfrSyntaxParser.Union - 78)) | (1 << (VfrSyntaxParser.TypeDef - 78)))) != 0): + self.state = 407 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,0,self._ctx) + if la_ == 1: + self.state = 404 + self.vfrPragmaPackDefinition() + pass + + elif la_ == 2: + self.state = 405 + self.vfrDataStructDefinition() + pass + + elif la_ == 3: + self.state = 406 + self.vfrDataUnionDefinition() + pass + + + self.state = 411 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 412 + self.vfrFormSetDefinition() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PragmaPackShowDefContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_pragmaPackShowDef + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPragmaPackShowDef" ): + return visitor.visitPragmaPackShowDef(self) + else: + return visitor.visitChildren(self) + + + + + def pragmaPackShowDef(self): + + localctx = VfrSyntaxParser.PragmaPackShowDefContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef) + try: + self.enterOuterAlt(localctx, 1) + self.state = 414 + self.match(VfrSyntaxParser.T__0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PragmaPackStackDefContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Comma(self, i:int=None): + if i is None: + return self.getTokens(VfrSyntaxParser.Comma) + else: + return self.getToken(VfrSyntaxParser.Comma, i) + + def StringIdentifier(self): + return self.getToken(VfrSyntaxParser.StringIdentifier, 0) + + def Number(self): + return self.getToken(VfrSyntaxParser.Number, 0) + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_pragmaPackStackDef + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPragmaPackStackDef" ): + return visitor.visitPragmaPackStackDef(self) + else: + return visitor.visitChildren(self) + + + + + def pragmaPackStackDef(self): + + localctx = VfrSyntaxParser.PragmaPackStackDefContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_pragmaPackStackDef) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 416 + _la = self._input.LA(1) + if not(_la==VfrSyntaxParser.T__1 or _la==VfrSyntaxParser.T__2): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 419 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,2,self._ctx) + if la_ == 1: + self.state = 417 + self.match(VfrSyntaxParser.Comma) + self.state = 418 + self.match(VfrSyntaxParser.StringIdentifier) + + + self.state = 423 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.Comma: + self.state = 421 + self.match(VfrSyntaxParser.Comma) + self.state = 422 + self.match(VfrSyntaxParser.Number) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PragmaPackNumberContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Number(self): + return self.getToken(VfrSyntaxParser.Number, 0) + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_pragmaPackNumber + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPragmaPackNumber" ): + return visitor.visitPragmaPackNumber(self) + else: + return visitor.visitChildren(self) + + + + + def pragmaPackNumber(self): + + localctx = VfrSyntaxParser.PragmaPackNumberContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_pragmaPackNumber) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.Number: + self.state = 425 + self.match(VfrSyntaxParser.Number) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VfrPragmaPackDefinitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OpenParen(self): + return self.getToken(VfrSyntaxParser.OpenParen, 0) + + def CloseParen(self): + return self.getToken(VfrSyntaxParser.CloseParen, 0) + + def pragmaPackShowDef(self): + return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackShowDefContext,0) + + + def pragmaPackStackDef(self): + return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackStackDefContext,0) + + + def pragmaPackNumber(self): + return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackNumberContext,0) + + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_vfrPragmaPackDefinition + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVfrPragmaPackDefinition" ): + return visitor.visitVfrPragmaPackDefinition(self) + else: + return visitor.visitChildren(self) + + + + + def vfrPragmaPackDefinition(self): + + localctx = VfrSyntaxParser.VfrPragmaPackDefinitionContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition) + try: + self.enterOuterAlt(localctx, 1) + self.state = 428 + self.match(VfrSyntaxParser.T__3) + self.state = 429 + self.match(VfrSyntaxParser.T__4) + self.state = 430 + self.match(VfrSyntaxParser.OpenParen) + self.state = 434 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,5,self._ctx) + if la_ == 1: + self.state = 431 + self.pragmaPackShowDef() + + elif la_ == 2: + self.state = 432 + self.pragmaPackStackDef() + + elif la_ == 3: + self.state = 433 + self.pragmaPackNumber() + + + self.state = 436 + self.match(VfrSyntaxParser.CloseParen) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VfrDataStructDefinitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.N1 = None # Token + self.N2 = None # Token + + def Struct(self): + return self.getToken(VfrSyntaxParser.Struct, 0) + + def OpenBrace(self): + return self.getToken(VfrSyntaxParser.OpenBrace, 0) + + def vfrDataStructFields(self): + return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0) + + + def CloseBrace(self): + return self.getToken(VfrSyntaxParser.CloseBrace, 0) + + def Semicolon(self): + return self.getToken(VfrSyntaxParser.Semicolon, 0) + + def TypeDef(self): + return self.getToken(VfrSyntaxParser.TypeDef, 0) + + def NonNvDataMap(self): + return self.getToken(VfrSyntaxParser.NonNvDataMap, 0) + + def StringIdentifier(self, i:int=None): + if i is None: + return self.getTokens(VfrSyntaxParser.StringIdentifier) + else: + return self.getToken(VfrSyntaxParser.StringIdentifier, i) + + def getRuleIndex(self): + return VfrSyntaxParser.RULE_vfrDataStructDefinition + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVfrDataStructDefinition" ): + return visitor.visitVfrDataStructDefinition(self) + else: + return visitor.visitChildren(self) + + + + + def vfrDataStructDefinition(self): + + localctx = VfrSyntaxParser.VfrDataStructDefinitionContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_vfrDataStructDefinition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 439 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.TypeDef: + self.state = 438 + self.match(VfrSyntaxParser.TypeDef) + + + self.state = 441 + self.match(VfrSyntaxParser.Struct) + self.state = 443 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.NonNvDataMap: + self.state = 442 + self.match(VfrSyntaxParser.NonNvDataMap) + + + self.state = 446 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.StringIdentifier: + self.state = 445 + localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier) + + + self.state = 448 + self.match(VfrSyntaxParser.OpenBrace) + self.state = 449 + self.vfrDataStructFields(False) + self.state = 450 + self.match(VfrSyntaxParser.CloseBrace) + self.state = 452 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==VfrSyntaxParser.StringIdentifier: + self.state = 451 + localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier) + + + self.state = 454 + self.match(VfrSyntaxParser.Semicolon) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VfrDataUnionDefinitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.N1 = None # Token + self.N2 = None # Token + + def Union(self): + return self.getToken(VfrSyntaxParser.Union, 0) + + def OpenBrace(self): + return self.getToken(VfrSyntaxParser.OpenBrace, 0) + + def vfrDataStructFields(self): + return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0) + + + def CloseBrace(self): + return self.getToken(VfrSyntaxParser.CloseBrace, 0) + + def Semicolon(self): + return self.getToken(VfrSyntaxParser.Semicolon, 0) + + def TypeDef(self): + return self.getToken(VfrSyntaxParser.TypeDef, 0) + + def NonNvDataMap(self): + return self |
|
Re: [Patch V2 2/3] [edk2-staging]BaseTools: Add new build option for PyVfrCompiler yaml generation
Bob Feng
Reviewed-by: Bob Feng <bob.c.feng@...>
toggle quoted message
Show quoted text
-----Original Message-----
From: Chen, Christine <yuwei.chen@...> Sent: Tuesday, November 15, 2022 4:46 PM To: devel@edk2.groups.io Cc: Feng, Bob C <bob.c.feng@...>; Gao, Liming <gaoliming@...> Subject: [Patch V2 2/3] [edk2-staging]BaseTools: Add new build option for PyVfrCompiler yaml generation Add new build option "--vfr-yaml-enable" for Python VfrCompiler extended output yaml file generation. Cc: Bob Feng <bob.c.feng@...> Cc: Liming Gao <gaoliming@...> Signed-off-by: Yuwei Chen <yuwei.chen@...> --- BaseTools/Source/Python/AutoGen/DataPipe.py | 2 ++ BaseTools/Source/Python/AutoGen/ModuleAutoGen.py | 8 ++++++++ BaseTools/Source/Python/Common/GlobalData.py | 4 ++++ BaseTools/Source/Python/build/build.py | 33 +++++++++++++++++++++++++++++++++ BaseTools/Source/Python/build/buildoptions.py | 1 + 5 files changed, 48 insertions(+) diff --git a/BaseTools/Source/Python/AutoGen/DataPipe.py b/BaseTools/Source/Python/AutoGen/DataPipe.py index 848c7a8296..c700baf7b7 100755 --- a/BaseTools/Source/Python/AutoGen/DataPipe.py +++ b/BaseTools/Source/Python/AutoGen/DataPipe.py @@ -171,3 +171,5 @@ class MemoryDataPipe(DataPipe): self.DataContainer = {"EnableGenfdsMultiThread":GlobalData.gEnableGenfdsMultiThread} self.DataContainer = {"gPlatformFinalPcds":GlobalData.gPlatformFinalPcds}++ self.DataContainer = {"VfrYamlEnable": GlobalData.gVfrYamlEnable}diff --git a/BaseTools/Source/Python/AutoGen/ModuleAutoGen.py b/BaseTools/Source/Python/AutoGen/ModuleAutoGen.py index d05410b329..eb81c3f3af 100755 --- a/BaseTools/Source/Python/AutoGen/ModuleAutoGen.py +++ b/BaseTools/Source/Python/AutoGen/ModuleAutoGen.py @@ -434,6 +434,14 @@ class ModuleAutoGen(AutoGen): def DebugDir(self): return _MakeDir((self.BuildDir, "DEBUG")) + @cached_property+ def VarIFiles(self):+ rt = []+ for SrcFile in self.SourceFileList:+ if SrcFile.Ext.lower() == '.vfr':+ rt.append(os.path.join(self.OutputDir, "{}.i".format(SrcFile.BaseName)))+ return rt+ ## Return the path of custom file @cached_property def CustomMakefile(self):diff --git a/BaseTools/Source/Python/Common/GlobalData.py b/BaseTools/Source/Python/Common/GlobalData.py index 197bd83666..039a9648aa 100755 --- a/BaseTools/Source/Python/Common/GlobalData.py +++ b/BaseTools/Source/Python/Common/GlobalData.py @@ -123,3 +123,7 @@ gSikpAutoGenCache = set() # Common lock for the file access in multiple process AutoGens file_lock = None +#+# Build flag for generate Yaml file from Vfr file+#+gVfrYamlEnable = Falsediff --git a/BaseTools/Source/Python/build/build.py b/BaseTools/Source/Python/build/build.py index 51fb1f433e..7e2f25686d 100755 --- a/BaseTools/Source/Python/build/build.py +++ b/BaseTools/Source/Python/build/build.py @@ -748,6 +748,7 @@ class Build(): GlobalData.gBinCacheSource = BuildOptions.BinCacheSource GlobalData.gEnableGenfdsMultiThread = not BuildOptions.NoGenfdsMultiThread GlobalData.gDisableIncludePathCheck = BuildOptions.DisableIncludePathCheck+ GlobalData.gVfrYamlEnable = BuildOptions.VfrYamlEnable if GlobalData.gBinCacheDest and not GlobalData.gUseHashCache: EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination must be used together with --hash.")@@ -1460,6 +1461,17 @@ class Build(): # genfds if Target == 'fds':+ if GlobalData.gVfrYamlEnable:+ from VfrCompiler.main import VfrParse+ variable_i_filelist = os.path.join(AutoGenObject.BuildDir,"variable_i_filelist.txt")+ if os.path.exists(variable_i_filelist):+ with open(variable_i_filelist) as file:+ i_filelist = file.readlines()+ for i_file in i_filelist:+ inputfile = i_file.replace("\n", "")+ yamloutputfile = inputfile.split(".")[0] + '.yaml'+ jsonoutputfile = inputfile.split(".")[0] + '.json'+ VfrParse(inputfile, yamloutputfile, jsonoutputfile) if GenFdsApi(AutoGenObject.GenFdsCommandDict, self.Db): EdkLogger.error("build", COMMAND_FAILURE) Threshold = self.GetFreeSizeThreshold()@@ -2246,6 +2258,15 @@ class Build(): fw.write("Arch=%s\n" % "|".join((Wa.ArchList))) fw.write("BuildDir=%s\n" % Wa.BuildDir) fw.write("PlatformGuid=%s\n" % str(Wa.AutoGenObjectList[0].Guid))+ variable_i_filelist = os.path.join(Wa.BuildDir,"variable_i_filelist.txt")+ vfr_var_i = []+ if GlobalData.gVfrYamlEnable:+ for ma in self.AllModules:+ vfr_var_i.extend(ma.VarIFiles)+ SaveFileOnChange(variable_i_filelist, "\n".join(vfr_var_i), False)+ else:+ if os.path.exists(variable_i_filelist):+ os.remove(variable_i_filelist) if GlobalData.gBinCacheSource: BuildModules.extend(self.MakeCacheMiss)@@ -2358,6 +2379,18 @@ class Build(): # # Generate FD image if there's a FDF file found #+ if GlobalData.gVfrYamlEnable:+ from VfrCompiler.main import VfrParse+ variable_i_filelist = os.path.join(Wa.BuildDir,"variable_i_filelist.txt")+ if os.path.exists(variable_i_filelist):+ with open(variable_i_filelist) as file:+ i_filelist = file.readlines()+ for i_file in i_filelist:+ inputfile = i_file.replace("\n", "")+ yamloutputfile = inputfile.split(".")[0] + '.yaml'+ jsonoutputfile = inputfile.split(".")[0] + '.json'+ print('inputfile ', inputfile)+ VfrParse(inputfile, yamloutputfile, jsonoutputfile) GenFdsStart = time.time() if GenFdsApi(Wa.GenFdsCommandDict, self.Db): EdkLogger.error("build", COMMAND_FAILURE)diff --git a/BaseTools/Source/Python/build/buildoptions.py b/BaseTools/Source/Python/build/buildoptions.py index 8334604b46..c0304c2f98 100644 --- a/BaseTools/Source/Python/build/buildoptions.py +++ b/BaseTools/Source/Python/build/buildoptions.py @@ -103,4 +103,5 @@ class MyOptionParser(): Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=True, help="Enable GenFds multi thread to generate ffs file.") Parser.add_option("--no-genfds-multi-thread", action="store_true", dest="NoGenfdsMultiThread", default=False, help="Disable GenFds multi thread to generate ffs file.") Parser.add_option("--disable-include-path-check", action="store_true", dest="DisableIncludePathCheck", default=False, help="Disable the include path check for outside of package.")+ Parser.add_option("--vfr-yaml-enable", action="store_true", dest="VfrYamlEnable", default=False, help="Enable the Vfr to yaml function.") self.BuildOption, self.BuildTarget = Parser.parse_args()-- 2.27.0.windows.1 |
|
[Patch 1/1] RedfishPkg: Remove overlapping private include path in DEC file
Michael D Kinney
Update ReadfishPkg.dec to remove PrivateInclude from the
[Includes.Common.Private] section. The PrivateInclude directory does not contain any include files, and the PrivateInclude/Crt include path remaining in the [Includes.Common.Private] section providing the include path required to access the CRT related include files by components within the RedfishPkg. Without this update, there are two forms of #include statements that can be used to include the CRT related include files. Include files should only be available using one form of #include statements. Cc: Abner Chang <abner.chang@...> Cc: Nickle Wang <nicklew@...> Cc: Igor Kulchytskyy <igork@...> Signed-off-by: Michael D Kinney <michael.d.kinney@...> --- RedfishPkg/RedfishPkg.dec | 1 - 1 file changed, 1 deletion(-) diff --git a/RedfishPkg/RedfishPkg.dec b/RedfishPkg/RedfishPkg.dec index 0aa26883e220..d2b189b13d8c 100644 --- a/RedfishPkg/RedfishPkg.dec +++ b/RedfishPkg/RedfishPkg.dec @@ -17,7 +17,6 @@ [Includes] Include [Includes.Common.Private] - PrivateInclude # Private header files for C RTL. PrivateInclude/Crt # Private header files for C RTL. Library/JsonLib # Private header files for jansson # configuration files. -- 2.37.1.windows.1 |
|
Tools and CI meeting
Sean
Sorry, super late in getting this notice out. Tonight was scheduled to be a brainstorming discussion on how to
enable CI in edk2 platforms and what kind of changes would be
required to the repo and the platforms hosted. If anyone is interested please join the meeting. If we don't get
enough representation we will host the topic next week as well
(12/12/2022).
Thanks Sean
|
|
Now: Tools, CI, Code base construction meeting series - Monday, December 5, 2022
#cal-notice
Group Notification <noreply@...>
Tools, CI, Code base construction meeting series When: Where: Description: TianoCore community, Microsoft and Intel will be hosting a series of open meetings to discuss build, CI, tools, and other related topics. If you are interested, have ideas/opinions please join us. These meetings will be Monday 4:30pm Pacific Time on Microsoft Teams. MS Teams Link in following discussion: * https://github.com/tianocore/edk2/discussions/2614 Anyone is welcome to join.
MS Teams Browser Clients * https://docs.microsoft.com/en-us/microsoftteams/get-clients?tabs=Windows#browser-client |
|
[edk2-wiki][PATCH v2 4/4] Update existing build instructions
Michael Kubacki
From: Michael Kubacki <michael.kubacki@...>
Adds a reference to existing documents in the wiki with build instructions to point to the new top-level build file. The original files are left in place for information reference and to prevent breaking links that may be pointing to them. Cc: Sean Brogan <sean.brogan@...> Cc: Michael D Kinney <michael.d.kinney@...> Cc: Liming Gao <gaoliming@...> Signed-off-by: Michael Kubacki <michael.kubacki@...> --- Build.mediawiki | 229 +++++----- BuildTool-Setup-Guide.mediawiki | 89 ++-- Common-instructions-for-Unix.mediawiki | 377 +++++++-------- Common-instructions.mediawiki | 211 ++++----- Getting-Started-with-EDK-II.mediawiki | 16 +- UDK2017-How-to-Build.md | 252 +++++----- UDK2018-How-to-Build.md | 262 +++++------ Unix-like-systems.mediawiki | 425 ++++++++--------- Using-EDK-II-with-Native-GCC.mediawiki | 483 ++++++++++---------- Windows-systems.mediawiki | 314 ++++++------- 10 files changed, 1352 insertions(+), 1306 deletions(-) diff --git a/Build.mediawiki b/Build.mediawiki index 19517eaef4e3..8e16cb12576b 100644 --- a/Build.mediawiki +++ b/Build.mediawiki @@ -1,114 +1,115 @@ -=Frequently asked EDK II build questions= - -==Regarding the Build for EDK II, how do you specify a different compiler tool chain on the command line?== - -Use –t parameter for the build command. Example: Using the Microsoft Visual Studio 2005 tool chain ... - - build –t VS2005 - -For using other tools see [[Getting_Started_with_EDK_II]]. This provides some detailed instructions for setting up some different tool chains? The file Conf/tools_def.txt contains a list of targets. - -==Is it possible to use PCDs @ build time?== - -It depends on what you are trying to do. For use in code, yes. -For example Featureflag PCD type can be used. For determining if something should be built then it might be better to use the “Build –D MACRO-NAME” options. - -==Is there information on Building on Linux?== - -For EDK II, yes, the build tools will need to be recompiled for GCC. Link for how to Build for GCC: -* [[Using EDK II with Native GCC]] -* [[Unix-like systems]] (For older Linux distributions, or when using Cygwin or Mac OS X) - -==What is the state of Python?== - -For Building EDK II Python of at least version 2.5 is needed. On Linux we've used 2.6 & 2.7. Python 3+ is not supported and will not work currently. On Windows, python is not required to be installed to build with EDK II. -There is a Python interpreter that is part of the EFI toolkit on tianocore.org and is at the Python version level 2.4, There are long term plans to move to EDK II and support a later version of Python as part of the [[AppPkg]]. It is currently (01/2012) in Aplha stage. - -==What does the parsing tool do?== - -The parsing is part of the first stage of the build process. There are tools for parsing the set build description files and the target.txt for a package or platform and creates the intermediate make and autogen files - -==Regarding writing UEFI Applications in EDK II, where is the output and/or the binary UEFI application after doing a build?== - -The Build output directory is defined in the defines section of a .DSC file. -For example, Nt32Pkg\Nt32Pkg.dsc - the UEFI application would be in Build\NT32\DEBUG_MYTOOLS\IA32 - - OUTPUT_DIRECTORY = Build/NT32 - SUPPORTED_ARCHITECTURES = IA32 - BUILD_TARGETS = DEBUG - -==How do I get my UEFI application to the target UEFI System?== - -Copy the UEFI Binary image from the output directory after the build to a USB thumb drive. Insert the USB drive in the UEFI target system. Boot to the EFI Shell. The USB thumb drive should be one of the file systems, e.g. FS0:. Cd to that USB drive and run your UEFI application from the shell prompt - -==Is the Build tool source code part of the Build?== - -No, the repository for the Tool Source is a separate project. The binaries by default are for a Windows build machine. For building on a non Windows machine there are instructions for recompiling the build tools. - -The sources are also in the BaseTools directory with the pre-build Windows executables. These sources are provided because they are the sources that were used to build the binaries. On Windows systems, the tools do not need to be built. The pre-build binaries can be used. One Linux, Unix, and OS/X systems, these sources are used to build the binaries for that OS, or in the case of Python, the Python sources are executed directly. - -The [[BaseTools]] Source Project is where advanced development is done on the EDK II tools. Tool developers work in this separate project until a new feature is stable, and only once it is stable is a feature added to the BaseTools directory and new binaries are generated. - -==Can we use Ifdefs?== - -This is not recommended but can be used within the DSC or FDF as part of the build. -But here is an example: - - !ifdef $(SOURCE_DEBUG_ENABLE) - MSFT:*_*_X64_GENFW_FLAGS = --keepexceptiontable - GCC:*_*_X64_GENFW_FLAGS = --keepexceptiontable - INTEL:*_*_X64_GENFW_FLAGS = --keepexceptiontable - !endif - -==When can the report generator show the protocols produced by modules?== - -The report generator can show protocols produced by modules. The Runtime DXE core will also report what is missing before handing off. - -==Why is the Buffer Security check flag (Build options) disabled for building EDK II UEFI applications and drivers but it is enabled for building tools. == - -UEFI applications and drivers are not executed in an Operating System environment. This is important, as the switches have very specific (and, in the pre-boot space, negative) impacts on generated code. The switch does two things in the code that are not acceptable for the pre-boot environment: - -* The switch enables additional code in the compiled code base, which requires a larger stack space than may be available in the pre-boot environment -* The switch injects a call to a compiler specific function that is not present in our Firmware builds, and which we do not have information on how to emulate. - -We disable these settings, as enabling them would create non-functioning code. - -However, please be aware that Detecting Stack Overflows in Firmware is critical in validation and development, and we use other techniques in our code to do so. We just cannot generically support the /Gs flags (as noted above). - -The tools do have this flag set, as they are used within the Operating System environment, where the intrinsic added by the compiler can be processed correctly. - -==Are there Dual-mode drivers in EDK II?== - -No. The EDK II build system does not support the dual mode drivers described in the PI Specification. These types of modules are very difficult to implement correctly, so we recommend that developer implement two different modules instead. The EDK II does allow them to share sources, but 2 different PE/COFF images would be generated when built. - -==Is there a tool to parse the BIOS Build tree?== - -a) Use the report generator build into the build tool “BUILD –Y” on the command line - - -Y REPORTTYPE, --report-type=REPORTTYPE - Flags that control the type of build report to - generate. Must be one of: [PCD, LIBRARY, FLASH, DEPEX, - BUILD_FLAGS, FIXED_ADDRESS, EXECUTION_ORDER]. - To specify more than one flag, repeat this option on - the command line and the default flag set is [PCD, - LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS] - Use “–Y DEPEX” and this will generate a text file with dependencies - - -b) Predicted dispatch order is limited because it makes assumptions about the behavior of the modules. It cannot handle that some PPI and DXE protocols that might be conditionally produced. Documented in the EDK2010 March 2010 release notes. - -c) Behavior of dispatch – filter for DEBUG_DISPATCH in DSC in the PCD for the error level PcdDebugPrintErrorLevel - -==How does the build tool load the reset vector at 0xFFFFFFF0?== - -This is defined in the PI Specification, Volume 3. http://www.uefi.org/specs - -In the FV (Firmware Volume) there is something called a Volume Top File inf the FV . A Volume Top File (VTF) is a file that must be located such that the last byte of the file is also the last byte of the firmware volume. Regardless of the file type, a VTF must have the file name GUID of EFI_FFS_VOLUME_TOP_FILE_GUID as defined below. - -From a PI point of view the first module that runs is the SEC core. If you look at the VTF file it is basically the code that contains the reset vector, and it jumps to the SEC code. - -Reference: https://github.com/tianocore/edk2/tree/master/UefiCpuPkg/ResetVector/Vtf0 - -So the hard code bit is the FV (Firmware Volume) that that contains the Volume Top File needs to start at an address where the end of the FV will end up at the magic reset vector address. - -In general the EFI build system constructs relocatable PE/COFF images, and every image is linked at zero. If the code executes from FLASH, then when the FV is constructed the PE/COFF images that are XIP (eXecute In Place) have their PE/COFF image relocated based on where they end up in the FV (based on info in FDF file). This is done by the build system. If the EFI code runs from RAM then it is loaded by a PE/COFF loader and relocated to its load address. +=Frequently asked EDK II build questions= + + Note: This page is retained for reference. Most of the content as of 2022 is still relevant but it is recommended to + view the new set of build instructions that describe how to develop using containers and build with the Stuart + application. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +==Regarding the Build for EDK II, how do you specify a different compiler tool chain on the command line?== + +Use –t parameter for the build command. Example: Using the Microsoft Visual Studio 2019 tool chain ... + + build –t VS2019 + +For using other tools see [[Getting_Started_with_EDK_II]]. This provides some detailed instructions for setting up some different tool chains? The file Conf/tools_def.txt contains a list of targets. + +==Is it possible to use PCDs @ build time?== + +It depends on what you are trying to do. For use in code, yes. +For example Featureflag PCD type can be used. For determining if something should be built then it might be better to use the “Build –D MACRO-NAME” options. + +==Is there information on Building on Linux?== + +For EDK II, yes, the build tools will need to be recompiled for GCC. Link for how to Build for GCC: +* [[Using EDK II with Native GCC]] +* [[Unix-like systems]] (For older Linux distributions, or when using Cygwin or Mac OS X) + +==What does the parsing tool do?== + +The parsing is part of the first stage of the build process. There are tools for parsing the set build description files and the target.txt for a package or platform and creates the intermediate make and autogen files + +==Regarding writing UEFI Applications in EDK II, where is the output and/or the binary UEFI application after doing a build?== + +The Build output directory is defined in the defines section of a .DSC file. +For example, Nt32Pkg\Nt32Pkg.dsc - the UEFI application would be in Build\NT32\DEBUG_MYTOOLS\IA32 + + OUTPUT_DIRECTORY = Build/NT32 + SUPPORTED_ARCHITECTURES = IA32 + BUILD_TARGETS = DEBUG + +==How do I get my UEFI application to the target UEFI System?== + +Copy the UEFI Binary image from the output directory after the build to a USB thumb drive. Insert the USB drive in the UEFI target system. Boot to the EFI Shell. The USB thumb drive should be one of the file systems, e.g. FS0:. Cd to that USB drive and run your UEFI application from the shell prompt + +==Is the Build tool source code part of the Build?== + +No, the repository for the Tool Source is a separate project. The binaries by default are for a Windows build machine. For building on a non Windows machine there are instructions for recompiling the build tools. + +The sources are also in the BaseTools directory with the pre-build Windows executables. These sources are provided because they are the sources that were used to build the binaries. On Windows systems, the tools do not need to be built. The pre-build binaries can be used. One Linux, Unix, and OS/X systems, these sources are used to build the binaries for that OS, or in the case of Python, the Python sources are executed directly. + +The [[BaseTools]] Source Project is where advanced development is done on the EDK II tools. Tool developers work in this separate project until a new feature is stable, and only once it is stable is a feature added to the BaseTools directory and new binaries are generated. + +==Can we use Ifdefs?== + +This is not recommended but can be used within the DSC or FDF as part of the build. +But here is an example: + + !ifdef $(SOURCE_DEBUG_ENABLE) + MSFT:*_*_X64_GENFW_FLAGS = --keepexceptiontable + GCC:*_*_X64_GENFW_FLAGS = --keepexceptiontable + INTEL:*_*_X64_GENFW_FLAGS = --keepexceptiontable + !endif + +==When can the report generator show the protocols produced by modules?== + +The report generator can show protocols produced by modules. The Runtime DXE core will also report what is missing before handing off. + +==Why is the Buffer Security check flag (Build options) disabled for building EDK II UEFI applications and drivers but it is enabled for building tools. == + +UEFI applications and drivers are not executed in an Operating System environment. This is important, as the switches have very specific (and, in the pre-boot space, negative) impacts on generated code. The switch does two things in the code that are not acceptable for the pre-boot environment: + +* The switch enables additional code in the compiled code base, which requires a larger stack space than may be available in the pre-boot environment +* The switch injects a call to a compiler specific function that is not present in our Firmware builds, and which we do not have information on how to emulate. + +We disable these settings, as enabling them would create non-functioning code. + +However, please be aware that Detecting Stack Overflows in Firmware is critical in validation and development, and we use other techniques in our code to do so. We just cannot generically support the /Gs flags (as noted above). + +The tools do have this flag set, as they are used within the Operating System environment, where the intrinsic added by the compiler can be processed correctly. + +==Are there Dual-mode drivers in EDK II?== + +No. The EDK II build system does not support the dual mode drivers described in the PI Specification. These types of modules are very difficult to implement correctly, so we recommend that developer implement two different modules instead. The EDK II does allow them to share sources, but 2 different PE/COFF images would be generated when built. + +==Is there a tool to parse the BIOS Build tree?== + +a) Use the report generator build into the build tool “BUILD –Y” on the command line + + -Y REPORTTYPE, --report-type=REPORTTYPE + Flags that control the type of build report to + generate. Must be one of: [PCD, LIBRARY, FLASH, DEPEX, + BUILD_FLAGS, FIXED_ADDRESS, EXECUTION_ORDER]. + To specify more than one flag, repeat this option on + the command line and the default flag set is [PCD, + LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS] + Use “–Y DEPEX” and this will generate a text file with dependencies + + +b) Predicted dispatch order is limited because it makes assumptions about the behavior of the modules. It cannot handle that some PPI and DXE protocols that might be conditionally produced. Documented in the EDK2010 March 2010 release notes. + +c) Behavior of dispatch – filter for DEBUG_DISPATCH in DSC in the PCD for the error level PcdDebugPrintErrorLevel + +==How does the build tool load the reset vector at 0xFFFFFFF0?== + +This is defined in the PI Specification, Volume 3. http://www.uefi.org/specs + +In the FV (Firmware Volume) there is something called a Volume Top File inf the FV . A Volume Top File (VTF) is a file that must be located such that the last byte of the file is also the last byte of the firmware volume. Regardless of the file type, a VTF must have the file name GUID of EFI_FFS_VOLUME_TOP_FILE_GUID as defined below. + +From a PI point of view the first module that runs is the SEC core. If you look at the VTF file it is basically the code that contains the reset vector, and it jumps to the SEC code. + +Reference: https://github.com/tianocore/edk2/tree/master/UefiCpuPkg/ResetVector/Vtf0 + +So the hard code bit is the FV (Firmware Volume) that that contains the Volume Top File needs to start at an address where the end of the FV will end up at the magic reset vector address. + +In general the EFI build system constructs relocatable PE/COFF images, and every image is linked at zero. If the code executes from FLASH, then when the FV is constructed the PE/COFF images that are XIP (eXecute In Place) have their PE/COFF image relocated based on where they end up in the FV (based on info in FDF file). This is done by the build system. If the EFI code runs from RAM then it is loaded by a PE/COFF loader and relocated to its load address. diff --git a/BuildTool-Setup-Guide.mediawiki b/BuildTool-Setup-Guide.mediawiki index 445ef25af598..45a80406395f 100644 --- a/BuildTool-Setup-Guide.mediawiki +++ b/BuildTool-Setup-Guide.mediawiki @@ -1,43 +1,46 @@ -=GitHub Help= - -GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub - -* Setup GitHub for Linux | Windows | MAC | All (https://help.github.com/articles/set-up-git) -* To download and install a Git GUI interface (http://git-scm.com/) - -=='''GitHub EDK II Project Repositories'''== - -* The EDK II BaseTools are part of the EDK II project repository. -* The EDK II project repository is available at https://github.com/tianocore/edk2. -* Prebuilt Windows tools are available at https://github.com/tianocore/edk2-BaseTools-win32. -* Content that is not released under an accepted open source license can be found at https://github.com/tianocore/edk2-non-osi.<BR> -= Getting the extra tools= -== Compiler == -For both the BuildTools and [http://www.tianocore.org/edk2/ EDK II] projects, you will need to obtain a compiler from somewhere else. These instructions do not cover obtaining or installation of a compiler tools chain. The BaseTools build requires a C compiler; an assembler or ACPI assembler are not required to build tools in this project. BaseTools assume that a compiler is already configured in the environment. - -== Python == -The BaseTools build supports the Makefile based build for EDK II. All Tools are written in either C or Python. The C tools must compile on all operating systems with various compilers, so the code is written using simple, standard functions and libraries. The Python-based tools are written assuming the features that were available in Python. GUI applications can be created in Python, using the wxPython package and all Python applications can be converted to run under a native OS (Windows, Linux or OS/X.) via the [[Python Tools]]. - -The tools in this section are NOT required to build the EDK II project; they are needed to compile the -BaseTools used to build the EDK II project. - -The Python 2.7.x tools may be obtained from http://www.python.org/, while additional Python modules may be installed using setuptools or pip. Be sure to check-out the appropriate tool set for your OS. - -*Linux and OS/X developers using a command line, create a directory that will be used to hold the files, then change to that directory. -**Replace URL with apropriate one from [[Python Tools]]. Installation and configuration for these tools are left to the developer. - - - - -Refer to documentation in either the UserManuals or Source folders for more information. -* BuildTools [https://github.com/tianocore/buildtools-BaseTools/tree/master/UserManuals User Manuals] - -='''How to Setup the EDK II Tree'''= -See [[Getting Started with EDK II]] - -== EDK II Development Process == -After setting up your build environment see [[EDK II Development Process]] for making contributions to the EDK II Project. - -=Further Help= - -If you have questions about the code or run into obstacles getting things to work for you, please join our [[edk2-devel]] email list and ask your EDK II related questions on the list. +=GitHub Help= + + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub + +* Setup GitHub for Linux | Windows | MAC | All (https://help.github.com/articles/set-up-git) +* To download and install a Git GUI interface (http://git-scm.com/) + +=='''GitHub EDK II Project Repositories'''== + +* The EDK II BaseTools are part of the EDK II project repository. +* The EDK II project repository is available at https://github.com/tianocore/edk2. +* Prebuilt Windows tools are available at https://github.com/tianocore/edk2-BaseTools-win32. +* Content that is not released under an accepted open source license can be found at https://github.com/tianocore/edk2-non-osi.<BR> += Getting the extra tools= +== Compiler == +For both the BuildTools and [http://www.tianocore.org/edk2/ EDK II] projects, you will need to obtain a compiler from somewhere else. These instructions do not cover obtaining or installation of a compiler tools chain. The BaseTools build requires a C compiler; an assembler or ACPI assembler are not required to build tools in this project. BaseTools assume that a compiler is already configured in the environment. + +== Python == +The BaseTools build supports the Makefile based build for EDK II. All Tools are written in either C or Python. The C tools must compile on all operating systems with various compilers, so the code is written using simple, standard functions and libraries. The Python-based tools are written assuming the features that were available in Python. GUI applications can be created in Python, using the wxPython package and all Python applications can be converted to run under a native OS (Windows, Linux or OS/X.) via the [[Python Tools]]. + +The tools in this section are NOT required to build the EDK II project; they are needed to compile the +BaseTools used to build the EDK II project. + +*Linux and OS/X developers using a command line, create a directory that will be used to hold the files, then change to that directory. +**Replace URL with apropriate one from [[Python Tools]]. Installation and configuration for these tools are left to the developer. + + + + +Refer to documentation in either the UserManuals or Source folders for more information. +* BuildTools [https://github.com/tianocore/buildtools-BaseTools/tree/master/UserManuals User Manuals] + +='''How to Setup the EDK II Tree'''= +See [[Getting Started with EDK II]] + +== EDK II Development Process == +After setting up your build environment see [[EDK II Development Process]] for making contributions to the EDK II Project. + +=Further Help= + +If you have questions about the code or run into obstacles getting things to work for you, please join our [[edk2-devel]] email list and ask your EDK II related questions on the list. diff --git a/Common-instructions-for-Unix.mediawiki b/Common-instructions-for-Unix.mediawiki index d15d3ffa0881..2432695e8844 100644 --- a/Common-instructions-for-Unix.mediawiki +++ b/Common-instructions-for-Unix.mediawiki @@ -1,186 +1,191 @@ -__NOTOC__ -==Common instructions for Unix == - -A significant portion of the steps are common on the various UNIX-like platforms. You should start with the instructions for the operating system that most closely matches your platform, and it will direct you here at the appropriate time. - -Note these instructions are not for current Linux distributions, only UNIX-like systems that do not work with the [[Using EDK II with Native GCC]] instructions. Please follow the [[Using EDK II with Native GCC]] guide for mainstream Linux distros. - -===Get the edk2 source tree using Git === - -<pre> -bash$ mkdir ~/src -bash$ cd ~/src -bash$ git clone https://github.com/tianocore/edk2 -</pre> - -====For EDKII project developers:==== -* Clone the EDK II project repository -** git clone https://github.com/tianocore/edk2 -* Change to the edk2 directory -* Build the tools -** make -C BaseTools -* Run the edksetup.sh script -** . edksetup.sh -When the above steps are done, you can work in the edk2 directory for code development. - -===Build the EDK II BaseTools=== - -<pre> -bash$ make -C edk2/BaseTools -</pre> - -===Build gcc x64 UEFI cross compiler=== - -In order to build UEFI images for x64, you will need to build a cross-compiler build of gcc. This can take quite a while to complete, possibly several hours on older systems. But, a Python script has been provided to automate this build process. - -Note: This is only needed if behind a internet firewall! -<pre> -bash$ export http_proxy=http://proxy.domain.com:proxy_port -</pre> - -To build gcc for x64, use these commands (this will take quite a while to complete): - -<pre> -bash$ cd ~/src/edk2/BaseTools/gcc -bash$ ./mingw-gcc-build.py --arch=x64 \ - --prefix=~/programs/gcc/x64 -</pre> - -===Setup build shell environment=== - -<pre> -bash$ cd ~/src/edk2 -bash$ export EDK_TOOLS_PATH=~/src/edk2/BaseTools -bash$ . edksetup.sh BaseTools -</pre> - -===Modify Conf Files=== - -You will need to edit the Conf/tools_def.txt and Conf/target.txt files. These changes will enable the MdeModulePkg to be built using the gcc x64 compiler. - -====Enable GCC X64 Cross-Compiler==== - -For the Conf/tools_def.txt file, find the following entry and comment the line out: - -<pre> -DEFINE UNIXGCC_X64_PETOOLS_PREFIX = /opt/tiano/x86_64-pc-mingw64/x86_64-pc-mingw64/bin/ -</pre> - -Next, find the following entry and uncomment the line: - -<pre> -DEFINE UNIXGCC_X64_PETOOLS_PREFIX = ENV(HOME)/programs/gcc/x64/bin/x86_64-pc-mingw32- -</pre> - -====Set Build Target Information==== - -For the Conf/target.txt file, find the following lines: - -<pre> -ACTIVE_PLATFORM = Nt32Pkg/Nt32Pkg.dsc -TARGET_ARCH = IA32 -TOOL_CHAIN_TAG = MYTOOLS -</pre> - -And change the cooresponding lines to match these: - -<pre> -ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc -TARGET_ARCH = X64 -TOOL_CHAIN_TAG = UNIXGCC -</pre> - -===Build Hello World! (and the rest of MdeModulePkg)=== - -Now you should be able to simply run the build command to compile the MdeModulePkg. - -<pre> -bash$ build -</pre> - -As a tangible result of the build, you should have the HelloWorld UEFI X64 application. If you have a X64 UEFI system available to you, then this application should be able to run successfully under the shell. - -<pre> -bash$ ls Build/MdeModule/DEBUG_UNIXGCC/X64/HelloWorld.efi -</pre> - -==Enabling Other Tools== - -The above showed how to setup an X64 build environment for building the core MdeModulePkg. However, other packages may require additional tools such as an IA32 cross-compiler and an ASL compiler. The steps to build these tools are described in this section. - -===Build gcc IA32 UEFI cross compiler=== - -In order to build UEFI images for IA32, you will need to build a cross-compiler build of gcc. This can take quite a while to complete, possibly several hours on older systems. But, a Python script has been provided to automate this build process. - -Note: This is only needed if behind a internet firewall! -<pre> -bash$ export http_proxy=http://proxy.domain.com:proxy_port -</pre> - -To build gcc for IA32, use these commands (this will take quite a while to complete): - -<pre> -bash$ cd ~/src/edk2/BaseTools/gcc -bash$ ./mingw-gcc-build.py --arch=ia32 \ - --prefix=~/programs/gcc/ia32 -</pre> - -====Modify Conf Files==== - -Once the cross-compiler has been successfully built the Conf/tools_def.txt will need to be updated so the cross-compiler can be used. - -Find the following statement in Conf/tools_def.txt and comment the line out: - -<pre> -DEFINE UNIXGCC_IA32_PETOOLS_PREFIX = /opt/tiano/i386-tiano-pe/i386-tiano-pe/bin/ -</pre> - -Next, find the following statement and uncomment the line: - -<pre> -DEFINE UNIXGCC_IA32_PETOOLS_PREFIX = ENV(HOME)/programs/gcc/ia32/bin/i686-pc-mingw32- -</pre> - -To enable building your target image with IA32 support the Conf/target.txt will also need to be modified. - -Find the TARGET_ARCH definition in Conf/target.txt and change the corresponding line to match this - -<pre> -TARGET_ARCH = IA32 -</pre> - -===Build the Intel ASL (iasl) compiler=== - -The Intel ASL compiler is not required for all edk2 developers. It is unlikely that UEFI Application or UEFI Driver builds will need an ASL compiler. But, if you are building an entire system firmware image, then you may need an ASL compiler. For example, the edk2 OVMF sample platform does require an ASL compiler in order to be built. - -First, download the latest ACPI-CA release from http://www.acpica.org. - -'''OS X users''': At this time, the latest versions of ACPI-CA are not building on Mac OS X, so please use the release from 20081031 instead. - -<pre> -bash$ cd ~/src -bash$ wget http://www.acpica.org/download/acpica-unix-20090521.tar.gz -bash$ tar -zxf acpica-unix-20090521.tar.gz -bash$ make -C acpica-unix-20090521/compiler -bash$ ln -s ~/src/acpica-unix-20090521/compiler/iasl ~/programs/iasl -</pre> - -====Modify Conf Files==== - -Once the Intel ASL compiler has been successfully built the Conf/tools_def.txt will need to be updated so the ASL compiler can be used. - -Find the following statement in Conf/tools_def.txt and comment the line out: - -<pre> -DEFINE UNIX_IASL_BIN = /usr/bin/iasl -</pre> - -Next, find the following statement and uncomment the line: - -<pre> -DEFINE UNIX_IASL_BIN = $(HOME)/programs/iasl -</pre> - -===Build [http://www.tianocore.org/ovmf/ OVMF]=== - -Once your build environment is set up you might be interested in building the [http://www.tianocore.org/ovmf/ OVMF] platform which is included in the main edk2 source tree. Since [http://www.tianocore.org/ovmf/ OVMF] builds a full system firmware image this may be of interest to UEFI system firmware developers. +__NOTOC__ +==Common instructions for Unix == + + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +A significant portion of the steps are common on the various UNIX-like platforms. You should start with the instructions for the operating system that most closely matches your platform, and it will direct you here at the appropriate time. + +Note these instructions are not for current Linux distributions, only UNIX-like systems that do not work with the [[Using EDK II with Native GCC]] instructions. Please follow the [[Using EDK II with Native GCC]] guide for mainstream Linux distros. + +===Get the edk2 source tree using Git === + +<pre> +bash$ mkdir ~/src +bash$ cd ~/src +bash$ git clone https://github.com/tianocore/edk2 +</pre> + +====For EDKII project developers:==== +* Clone the EDK II project repository +** git clone https://github.com/tianocore/edk2 +* Change to the edk2 directory +* Build the tools +** make -C BaseTools +* Run the edksetup.sh script +** . edksetup.sh +When the above steps are done, you can work in the edk2 directory for code development. + +===Build the EDK II BaseTools=== + +<pre> +bash$ make -C edk2/BaseTools +</pre> + +===Build gcc x64 UEFI cross compiler=== + +In order to build UEFI images for x64, you will need to build a cross-compiler build of gcc. This can take quite a while to complete, possibly several hours on older systems. But, a Python script has been provided to automate this build process. + +Note: This is only needed if behind a internet firewall! +<pre> +bash$ export http_proxy=http://proxy.domain.com:proxy_port +</pre> + +To build gcc for x64, use these commands (this will take quite a while to complete): + +<pre> +bash$ cd ~/src/edk2/BaseTools/gcc +bash$ ./mingw-gcc-build.py --arch=x64 \ + --prefix=~/programs/gcc/x64 +</pre> + +===Setup build shell environment=== + +<pre> +bash$ cd ~/src/edk2 +bash$ export EDK_TOOLS_PATH=~/src/edk2/BaseTools +bash$ . edksetup.sh BaseTools +</pre> + +===Modify Conf Files=== + +You will need to edit the Conf/tools_def.txt and Conf/target.txt files. These changes will enable the MdeModulePkg to be built using the gcc x64 compiler. + +====Enable GCC X64 Cross-Compiler==== + +For the Conf/tools_def.txt file, find the following entry and comment the line out: + +<pre> +DEFINE UNIXGCC_X64_PETOOLS_PREFIX = /opt/tiano/x86_64-pc-mingw64/x86_64-pc-mingw64/bin/ +</pre> + +Next, find the following entry and uncomment the line: + +<pre> +DEFINE UNIXGCC_X64_PETOOLS_PREFIX = ENV(HOME)/programs/gcc/x64/bin/x86_64-pc-mingw32- +</pre> + +====Set Build Target Information==== + +For the Conf/target.txt file, find the following lines: + +<pre> +ACTIVE_PLATFORM = Nt32Pkg/Nt32Pkg.dsc +TARGET_ARCH = IA32 +TOOL_CHAIN_TAG = MYTOOLS +</pre> + +And change the cooresponding lines to match these: + +<pre> +ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc +TARGET_ARCH = X64 +TOOL_CHAIN_TAG = UNIXGCC +</pre> + +===Build Hello World! (and the rest of MdeModulePkg)=== + +Now you should be able to simply run the build command to compile the MdeModulePkg. + +<pre> +bash$ build +</pre> + +As a tangible result of the build, you should have the HelloWorld UEFI X64 application. If you have a X64 UEFI system available to you, then this application should be able to run successfully under the shell. + +<pre> +bash$ ls Build/MdeModule/DEBUG_UNIXGCC/X64/HelloWorld.efi +</pre> + +==Enabling Other Tools== + +The above showed how to setup an X64 build environment for building the core MdeModulePkg. However, other packages may require additional tools such as an IA32 cross-compiler and an ASL compiler. The steps to build these tools are described in this section. + +===Build gcc IA32 UEFI cross compiler=== + +In order to build UEFI images for IA32, you will need to build a cross-compiler build of gcc. This can take quite a while to complete, possibly several hours on older systems. But, a Python script has been provided to automate this build process. + +Note: This is only needed if behind a internet firewall! +<pre> +bash$ export http_proxy=http://proxy.domain.com:proxy_port +</pre> + +To build gcc for IA32, use these commands (this will take quite a while to complete): + +<pre> +bash$ cd ~/src/edk2/BaseTools/gcc +bash$ ./mingw-gcc-build.py --arch=ia32 \ + --prefix=~/programs/gcc/ia32 +</pre> + +====Modify Conf Files==== + +Once the cross-compiler has been successfully built the Conf/tools_def.txt will need to be updated so the cross-compiler can be used. + +Find the following statement in Conf/tools_def.txt and comment the line out: + +<pre> +DEFINE UNIXGCC_IA32_PETOOLS_PREFIX = /opt/tiano/i386-tiano-pe/i386-tiano-pe/bin/ +</pre> + +Next, find the following statement and uncomment the line: + +<pre> +DEFINE UNIXGCC_IA32_PETOOLS_PREFIX = ENV(HOME)/programs/gcc/ia32/bin/i686-pc-mingw32- +</pre> + +To enable building your target image with IA32 support the Conf/target.txt will also need to be modified. + +Find the TARGET_ARCH definition in Conf/target.txt and change the corresponding line to match this + +<pre> +TARGET_ARCH = IA32 +</pre> + +===Build the Intel ASL (iasl) compiler=== + +The Intel ASL compiler is not required for all edk2 developers. It is unlikely that UEFI Application or UEFI Driver builds will need an ASL compiler. But, if you are building an entire system firmware image, then you may need an ASL compiler. For example, the edk2 OVMF sample platform does require an ASL compiler in order to be built. + +First, download the latest ACPI-CA release from http://www.acpica.org. + +'''OS X users''': At this time, the latest versions of ACPI-CA are not building on Mac OS X, so please use the release from 20081031 instead. + +<pre> +bash$ cd ~/src +bash$ wget http://www.acpica.org/download/acpica-unix-20090521.tar.gz +bash$ tar -zxf acpica-unix-20090521.tar.gz +bash$ make -C acpica-unix-20090521/compiler +bash$ ln -s ~/src/acpica-unix-20090521/compiler/iasl ~/programs/iasl +</pre> + +====Modify Conf Files==== + +Once the Intel ASL compiler has been successfully built the Conf/tools_def.txt will need to be updated so the ASL compiler can be used. + +Find the following statement in Conf/tools_def.txt and comment the line out: + +<pre> +DEFINE UNIX_IASL_BIN = /usr/bin/iasl +</pre> + +Next, find the following statement and uncomment the line: + +<pre> +DEFINE UNIX_IASL_BIN = $(HOME)/programs/iasl +</pre> + +===Build [http://www.tianocore.org/ovmf/ OVMF]=== + +Once your build environment is set up you might be interested in building the [http://www.tianocore.org/ovmf/ OVMF] platform which is included in the main edk2 source tree. Since [http://www.tianocore.org/ovmf/ OVMF] builds a full system firmware image this may be of interest to UEFI system firmware developers. diff --git a/Common-instructions.mediawiki b/Common-instructions.mediawiki index 6e752e5699db..956813cda163 100644 --- a/Common-instructions.mediawiki +++ b/Common-instructions.mediawiki @@ -1,103 +1,108 @@ -__NOTOC__ -=Common EDK II Build Instructions for Linux= - -These instructions assume you have installed Linux packages required for an [[EDK II]] build environment, including git (example: [https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC#Ubuntu_1604_LTS__Ubuntu_1610|Ubuntu 16.04/16.10]). The following instructions are common to the majority of Linux environments. - -===Get the edk2 source tree using Git === - -<pre> -bash$ mkdir ~/src -bash$ cd ~/src -bash$ git clone https://github.com/tianocore/edk2 -</pre> - -Note: the 'git clone' command above pulls the latest code from edk2. If you want to work from a stable release, specify a release tag when cloning. Example: - -<pre> -bash$ git clone https://github.com/tianocore/edk2.git vUDK2017 -</pre> - -===Initialize submodules=== - -<pre> -bash$ git submodule update --init -</pre> - -===Compile build tools === - -<pre> -bash$ cd ~/src/edk2 -bash$ make -C BaseTools -bash$ . edksetup.sh -</pre> - -When the above steps are done, you can work in the edk2 directory for code development. - -===Build the EDK II BaseTools=== - -<pre> -bash$ make -C edk2/BaseTools -</pre> - -===Setup build shell environment=== - -<pre> -bash$ cd ~/src/edk2 -bash$ export EDK_TOOLS_PATH=$HOME/src/edk2/BaseTools -bash$ . edksetup.sh BaseTools -</pre> - -===Modify Conf Files=== - -Running <code>edksetup.sh</code> populates the <code>edk2/Conf</code> directory with default configuration files. You will need to edit the <code>Conf/target.txt</code> file to set the build platform, target architecture, tool chain, and multi-threading options. The example below is based on building the <code>MdeModulePkg</code> using GCC5. - -====Set Build Target Information==== - -For the <code>Conf/target.txt</code> file, find the following lines: - -<pre> -ACTIVE_PLATFORM = Nt32Pkg/Nt32Pkg.dsc -TOOL_CHAIN_TAG = MYTOOLS -</pre> - -And change the corresponding lines to match these: - -<pre> -ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc -TOOL_CHAIN_TAG = GCC5 -</pre> - -:Note: The <code>gcc --version</code> command can be used to find out your GCC version. Use the '''GCC45''' toolchain for gcc 4.5.* and the '''GCC46''' toolchain for gcc 4.6.*. - -:Note: for GCC5 please install the gcc-5 package. Example for Ubuntu: <code>sudo apt-get install gcc-5</code> - -Locate the TARGET_ARCH setting: - -<pre> -TARGET_ARCH = IA32 -</pre> - -Change this reflect the build architecture for the final UEFI binary. - -:Example: <code>X64</code>, <code>IA32 X64</code> (which will build both architectures). - -Optional: enable multi-threaded build. The default value for <code>MAX_CONCURRENT_THREAD_NUMBER</code> is 1, which disables multi-threaded build. Change this value based on your system's multi-threading capabilities. The formula is '1 + (2 x processor threads)'. - -:Example: for an Intel Core i5 (two processor cores w/ hyperthreading), the value is <code>9</code>. - -===Build Hello World! (and the rest of MdeModulePkg)=== - -Now you should be able to simply run the build command to compile <code>MdeModulePkg</code>. - -<pre> -bash$ build -</pre> - -One result of the build is that you should have the HelloWorld UEFI application: -<pre> -bash$ ls Build/MdeModule/DEBUG_*/*/HelloWorld.efi -</pre> - -===Build [[OVMF]]=== - -Once your build environment is set up you might be interested in [[How to build OVMF|building the OVMF platform]] which is included in the main [[EDK II]] source tree. Since [[OVMF]] builds a full system firmware image, this may be of interest to UEFI system firmware developers. +__NOTOC__ +=Common EDK II Build Instructions for Linux= + + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +These instructions assume you have installed Linux packages required for an [[EDK II]] build environment, including git (example: [https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC#Ubuntu_1604_LTS__Ubuntu_1610|Ubuntu 16.04/16.10]). The following instructions are common to the majority of Linux environments. + +===Get the edk2 source tree using Git === + +<pre> +bash$ mkdir ~/src +bash$ cd ~/src +bash$ git clone https://github.com/tianocore/edk2 +</pre> + +Note: the 'git clone' command above pulls the latest code from edk2. If you want to work from a stable release, specify a release tag when cloning. Example: + +<pre> +bash$ git clone https://github.com/tianocore/edk2.git vUDK2017 +</pre> + +===Initialize submodules=== + +<pre> +bash$ git submodule update --init +</pre> + +===Compile build tools === + +<pre> +bash$ cd ~/src/edk2 +bash$ make -C BaseTools +bash$ . edksetup.sh +</pre> + +When the above steps are done, you can work in the edk2 directory for code development. + +===Build the EDK II BaseTools=== + +<pre> +bash$ make -C edk2/BaseTools +</pre> + +===Setup build shell environment=== + +<pre> +bash$ cd ~/src/edk2 +bash$ export EDK_TOOLS_PATH=$HOME/src/edk2/BaseTools +bash$ . edksetup.sh BaseTools +</pre> + +===Modify Conf Files=== + +Running <code>edksetup.sh</code> populates the <code>edk2/Conf</code> directory with default configuration files. You will need to edit the <code>Conf/target.txt</code> file to set the build platform, target architecture, tool chain, and multi-threading options. The example below is based on building the <code>MdeModulePkg</code> using GCC5. + +====Set Build Target Information==== + +For the <code>Conf/target.txt</code> file, find the following lines: + +<pre> +ACTIVE_PLATFORM = Nt32Pkg/Nt32Pkg.dsc +TOOL_CHAIN_TAG = MYTOOLS +</pre> + +And change the corresponding lines to match these: + +<pre> +ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc +TOOL_CHAIN_TAG = GCC5 +</pre> + +:Note: The <code>gcc --version</code> command can be used to find out your GCC version. Use the '''GCC45''' toolchain for gcc 4.5.* and the '''GCC46''' toolchain for gcc 4.6.*. + +:Note: for GCC5 please install the gcc-5 package. Example for Ubuntu: <code>sudo apt-get install gcc-5</code> + +Locate the TARGET_ARCH setting: + +<pre> +TARGET_ARCH = IA32 +</pre> + +Change this reflect the build architecture for the final UEFI binary. + +:Example: <code>X64</code>, <code>IA32 X64</code> (which will build both architectures). + +Optional: enable multi-threaded build. The default value for <code>MAX_CONCURRENT_THREAD_NUMBER</code> is 1, which disables multi-threaded build. Change this value based on your system's multi-threading capabilities. The formula is '1 + (2 x processor threads)'. + +:Example: for an Intel Core i5 (two processor cores w/ hyperthreading), the value is <code>9</code>. + +===Build Hello World! (and the rest of MdeModulePkg)=== + +Now you should be able to simply run the build command to compile <code>MdeModulePkg</code>. + +<pre> +bash$ build +</pre> + +One result of the build is that you should have the HelloWorld UEFI application: +<pre> +bash$ ls Build/MdeModule/DEBUG_*/*/HelloWorld.efi +</pre> + +===Build [[OVMF]]=== + +Once your build environment is set up you might be interested in [[How to build OVMF|building the OVMF platform]] which is included in the main [[EDK II]] source tree. Since [[OVMF]] builds a full system firmware image, this may be of interest to UEFI system firmware developers. diff --git a/Getting-Started-with-EDK-II.mediawiki b/Getting-Started-with-EDK-II.mediawiki index f616d1e86e4c..eb6da7dfdc56 100644 --- a/Getting-Started-with-EDK-II.mediawiki +++ b/Getting-Started-with-EDK-II.mediawiki @@ -1,4 +1,10 @@ __NOTOC__ + + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + =Downloading and Compiling Code= This page shows the steps for downloading [[EDK II]] from GitHub and compiling projects under various OS/compiler environments. @@ -15,24 +21,24 @@ Several build environments are supported and documented. If instructions are no '''Note:''' Some other build tools may be required depending on the project or package: * [[Nasm Setup|Nasm]] * [[ASL Setup|ASL Compiler]] -* Install Python 3.7 or later (https://www.python.org/) to run python tool from source +* Install Python 3.7 or later (https://www.python.org/) to run python tool from source ** Python 2.7.10 or later can still be used with PYTHON_HOME -'''Note:''' Some of the examples use the [[Multiple_Workspace]] `PACKAGES_PATH` feature to the configure EDK II build environment. For example, this is required for using platform code based on edk2-platforms: (https://github.com/tianocore/edk2-platforms). +'''Note:''' Some of the examples use the [[Multiple_Workspace]] `PACKAGES_PATH` feature to the configure EDK II build environment. For example, this is required for using platform code based on edk2-platforms: (https://github.com/tianocore/edk2-platforms). Once you have a basic build environment running, you can build a project in RELEASE or [[EDK II Debugging|DEBUG]] mode. ==GitHub Help== -GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub +GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub * Setup GitHub for Linux/Windows/MAC (https://help.github.com/articles/set-up-git) * Download and install a git GUI interface: git GUI Clients (https://git-scm.com/download/gui/win) | TortoiseGit (https://tortoisegit.org/) ===GitHub EDK II Project Repositories=== -* The EDK II project repository is available at https://github.com/tianocore/edk2. -* Prebuilt Windows tools are available at https://github.com/tianocore/edk2-BaseTools-win32. +* The EDK II project repository is available at https://github.com/tianocore/edk2. +* Prebuilt Windows tools are available at https://github.com/tianocore/edk2-BaseTools-win32. * [[EDK II Platforms]] are available at https://github.com/tianocore/edk2-platforms. * Content that is not released under an accepted open source license can be found at https://github.com/tianocore/edk2-non-osi. diff --git a/UDK2017-How-to-Build.md b/UDK2017-How-to-Build.md index 4eca47f98e21..2f7f80125513 100644 --- a/UDK2017-How-to-Build.md +++ b/UDK2017-How-to-Build.md @@ -1,123 +1,129 @@ -# How to Build [[UDK2017]] -Table of Contents -1) [HOW TO BUILD (WINDOWS SYSTEM)](#how-to-build-windows-system) -2) [ HOW TO BUILD (LINUX-LIKE SYSTEM)](#how-to-build-linux-like-system) - -## HOW TO BUILD (WINDOWS SYSTEM) - -The steps below are verified on Microsoft Windows 10 Enterprise*: - -1. Setup Build Environment - 1) Install Microsoft Visual Studio 2015* in the build machine and make - sure that AMD64 complier was selected when installing. - 2) Download NASM 2.0.7 or later from http://www.nasm.us/ and install it to - C:\Nasm. Make sure C:\Nasm is added to system environment variable 'PATH' - 3) Set up for using GitHub for Windows. See: - https://github.com/tianocore/tianocore.github.io/wiki/Getting-Started-with-EDK-II#github-help - 4) Download and install Python2.7.x https://www.python.org/ for building the BaseTools - Default install directory is: C:/Python27 - -2. Create the full Source Code directory for the UDK2017 release - 1) Create a working space directory in the build machine, for example, C:\MyWorkspace - 2) Download the official UDK2017 release .zip file from the [UDK2017 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2017) - 1) Download - UDK2017 edk-vUDK2017 Workspace [Source code (zip file)](https://github.com/tianocore/edk2/archive/vUDK2017.zip) - 2) Extract files in [edk2-vUDK2017] to the working space directory C:\MyWorkspace. - 3) **OR** Checkout the vUDK2017 Tag from GitHub with the following "git" command <br> - 1) run `git clone https://github.com/tianocore/edk2.git vUDK2017` - 2) Move all files and folders under "vUDK2017" to "C:\MyWorkspace" - 4) **Optional** (See _Compile the BaseTools_ below) Checkout BaseTools binaries and copy them to BaseTools binary folder. Warning the Windows* Binary tools are only valid for the tip of the https://github.com/tianocore/edk2 repository. - 1) `Cd C:\MyWorkspace` - 2) Run `git clone https://github.com/tianocore/edk2-BaseTools-win32.git` - 3) Enter folder edk2-BaseTools-win32 - 4) Run the command `git checkout 0e088c19ab31fccd1d2f55d9e4fe0314b57c0097` - 5) `Cd C:\MyWorkSpace` - 6) Rename this folder from edk2-BaseTools-win32 to win32, then copy the win32 - directory into the BaseTools/Bin directory under the workspace. - (e.g. "C:\MyWorkspace\BaseTools\Bin\") -3. Generate OpenSSL* Crypto Library - 1) Open file "C:\MyWorkspace\CryptoPkg\Library\OpensslLib\OpenSSL-HOWTO.txt" - and follow the instruction to install OpenSSL* for UEFI building. - For this release, please use OpenSSL-1.1.0e. - -4. Compile the BaseTools (Skip if Optional Step 2.iv was done above) See: - https://github.com/tianocore/tianocore.github.io/wiki/Windows-systems#compile-tools - 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` - to enter the workspace directory - 2) Compile the BaseTools C source tools -<pre> - set PYTHON_HOME=C:\Python27 - set EDK_TOOLS_PATH=%CD%\BaseTools - BaseTools\toolssetup.bat Rebuild -</pre> - -5. Build Steps - *** NT32 *** - - 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` - to enter the workspace directory - 2) Use edksetup.bat command to initialize the working environment. - `edksetup --nt32` - 3) Type following command to build Nt32 platform - `build -t VS2015x86` - 4) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the C:\MyWorkspace\Build\MdeModule\DEBUG_VS2015x86\IA32 directory - - ---- - -## HOW TO BUILD (LINUX-LIKE SYSTEM) -The below steps are verified on Ubuntu 16.04 LTS Desktop*: - -1. Setup Build Environment - 1) Follow instructions for setting up the build environment on tianocore.org. - "https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC" - 2) Please notice that here the root is `"~/src/MyWorkspace"` instead - of `"~/src/edk2"` - 3) Make sure BaseTools is built and required software like iASL compiler - are installed. Some operations need switch to user "root" to execute. - At Ubuntu, you can type `"sudo apt-get install git"` under terminal prompt "Cnt-Alt-T" to - install git. - 2) Install NASM 2.0.7 or later. - At Ubuntu, you can type `"sudo apt-get install nasm"` under terminal prompt to - install it. - You can also download the source package from http://www.nasm.us/ and - install it following the instruction on the website. - 3) Install IASL 20150818 or later. - At Ubuntu, you can type `"sudo apt-get install iasl"` under terminal prompt to - install it. - You can also download the source package from https://acpica.org/downloads - and install it following the instruction on the website. - 4) Install the C Compiler- Ubuntu 16.04 LTS you can use GNU C compiler (v5.4.0) - At Ubuntu, you can type `"sudo apt-get install gcc-5"` under terminal prompt to install it. - - -2. Create the full Source Code directory for the UDK2017 release - 1) Create a working space directory in the build machine, for example, ~/src/MyWorkspace - 2) Download the official UDK2017 release .tar file from the [UDK2017 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2017) - 1) Download - UDK2017 edk-vUDK2017 Workspace [Source code (tar.gz file)](https://github.com/tianocore/edk2/archive/vUDK2017.tar.gz) - 2) Extract files in [edk2-vUDK2017] to the working space directory ~/src/MyWorkspace. - 3) **OR** Checkout the vUDK2017 tag from GitHub with the following "git" command - 1) Run `"git clone https://github.com/tianocore/edk2.git vUDK2017"` - 2) Move all files and folders under "vUDK2017" to "~/src/MyWorkspace" - -3. Generate OpenSSL* Crypto Library - 1) Open file "~/src/MyWorkspace/CryptoPkg/Library/OpensslLib/OpenSSL-HOWTO.txt" - and follow the instruction to install OpenSSL* for UEFI building. - For this release, please use OpenSSL-1.1.0e. - -4. Build Steps - *** MdeModulePkg *** - 1) Open a terminal and type `"cd ~/src/MyWorkspace"` to enter the workspace - directory. - 2) First build the BaseTools by typing - `"make -C BaseTools"` - 3) Initialize the build environment by typing - `". edksetup.sh"`. - 4) Type following command to build platforms using GCC v5.4.0 <BR> - `"build -p MdeModulePkg/MdeModulePkg.dsc -t GCC5"` - 5) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the ~/src/MyWorkspace/Build/MdeModule/DEBUG_GCC5/IA32 directory -*** - -If you have questions please email the [[edk2-devel]] mail list. - -See also [[Getting Started with EDK II]] - +# How to Build [[UDK2017]] + +> Note: New build instructions are available. It is recommended to start with the new instructions if learning how to +> build edk2 for the first time and not specifically targeting UDK2017. This page is retained for reference. + +New instructions: [Build Instructions](Build-Instructions.md) + +Table of Contents +1) [HOW TO BUILD (WINDOWS SYSTEM)](#how-to-build-windows-system) +2) [ HOW TO BUILD (LINUX-LIKE SYSTEM)](#how-to-build-linux-like-system) + +## HOW TO BUILD (WINDOWS SYSTEM) + +The steps below are verified on Microsoft Windows 10 Enterprise*: + +1. Setup Build Environment + 1) Install Microsoft Visual Studio 2015* in the build machine and make + sure that AMD64 complier was selected when installing. + 2) Download NASM 2.0.7 or later from http://www.nasm.us/ and install it to + C:\Nasm. Make sure C:\Nasm is added to system environment variable 'PATH' + 3) Set up for using GitHub for Windows. See: + https://github.com/tianocore/tianocore.github.io/wiki/Getting-Started-with-EDK-II#github-help + 4) Download and install Python2.7.x https://www.python.org/ for building the BaseTools + Default install directory is: C:/Python27 + +2. Create the full Source Code directory for the UDK2017 release + 1) Create a working space directory in the build machine, for example, C:\MyWorkspace + 2) Download the official UDK2017 release .zip file from the [UDK2017 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2017) + 1) Download - UDK2017 edk-vUDK2017 Workspace [Source code (zip file)](https://github.com/tianocore/edk2/archive/vUDK2017.zip) + 2) Extract files in [edk2-vUDK2017] to the working space directory C:\MyWorkspace. + 3) **OR** Checkout the vUDK2017 Tag from GitHub with the following "git" command <br> + 1) run `git clone https://github.com/tianocore/edk2.git vUDK2017` + 2) Move all files and folders under "vUDK2017" to "C:\MyWorkspace" + 4) **Optional** (See _Compile the BaseTools_ below) Checkout BaseTools binaries and copy them to BaseTools binary folder. Warning the Windows* Binary tools are only valid for the tip of the https://github.com/tianocore/edk2 repository. + 1) `Cd C:\MyWorkspace` + 2) Run `git clone https://github.com/tianocore/edk2-BaseTools-win32.git` + 3) Enter folder edk2-BaseTools-win32 + 4) Run the command `git checkout 0e088c19ab31fccd1d2f55d9e4fe0314b57c0097` + 5) `Cd C:\MyWorkSpace` + 6) Rename this folder from edk2-BaseTools-win32 to win32, then copy the win32 + directory into the BaseTools/Bin directory under the workspace. + (e.g. "C:\MyWorkspace\BaseTools\Bin\") +3. Generate OpenSSL* Crypto Library + 1) Open file "C:\MyWorkspace\CryptoPkg\Library\OpensslLib\OpenSSL-HOWTO.txt" + and follow the instruction to install OpenSSL* for UEFI building. + For this release, please use OpenSSL-1.1.0e. + +4. Compile the BaseTools (Skip if Optional Step 2.iv was done above) See: + https://github.com/tianocore/tianocore.github.io/wiki/Windows-systems#compile-tools + 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` + to enter the workspace directory + 2) Compile the BaseTools C source tools +<pre> + set PYTHON_HOME=C:\Python27 + set EDK_TOOLS_PATH=%CD%\BaseTools + BaseTools\toolssetup.bat Rebuild +</pre> + +5. Build Steps + *** NT32 *** + + 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` + to enter the workspace directory + 2) Use edksetup.bat command to initialize the working environment. + `edksetup --nt32` + 3) Type following command to build Nt32 platform + `build -t VS2015x86` + 4) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the C:\MyWorkspace\Build\MdeModule\DEBUG_VS2015x86\IA32 directory + + +--- + +## HOW TO BUILD (LINUX-LIKE SYSTEM) +The below steps are verified on Ubuntu 16.04 LTS Desktop*: + +1. Setup Build Environment + 1) Follow instructions for setting up the build environment on tianocore.org. + "https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC" + 2) Please notice that here the root is `"~/src/MyWorkspace"` instead + of `"~/src/edk2"` + 3) Make sure BaseTools is built and required software like iASL compiler + are installed. Some operations need switch to user "root" to execute. + At Ubuntu, you can type `"sudo apt-get install git"` under terminal prompt "Cnt-Alt-T" to + install git. + 2) Install NASM 2.0.7 or later. + At Ubuntu, you can type `"sudo apt-get install nasm"` under terminal prompt to + install it. + You can also download the source package from http://www.nasm.us/ and + install it following the instruction on the website. + 3) Install IASL 20150818 or later. + At Ubuntu, you can type `"sudo apt-get install iasl"` under terminal prompt to + install it. + You can also download the source package from https://acpica.org/downloads + and install it following the instruction on the website. + 4) Install the C Compiler- Ubuntu 16.04 LTS you can use GNU C compiler (v5.4.0) + At Ubuntu, you can type `"sudo apt-get install gcc-5"` under terminal prompt to install it. + + +2. Create the full Source Code directory for the UDK2017 release + 1) Create a working space directory in the build machine, for example, ~/src/MyWorkspace + 2) Download the official UDK2017 release .tar file from the [UDK2017 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2017) + 1) Download - UDK2017 edk-vUDK2017 Workspace [Source code (tar.gz file)](https://github.com/tianocore/edk2/archive/vUDK2017.tar.gz) + 2) Extract files in [edk2-vUDK2017] to the working space directory ~/src/MyWorkspace. + 3) **OR** Checkout the vUDK2017 tag from GitHub with the following "git" command + 1) Run `"git clone https://github.com/tianocore/edk2.git vUDK2017"` + 2) Move all files and folders under "vUDK2017" to "~/src/MyWorkspace" + +3. Generate OpenSSL* Crypto Library + 1) Open file "~/src/MyWorkspace/CryptoPkg/Library/OpensslLib/OpenSSL-HOWTO.txt" + and follow the instruction to install OpenSSL* for UEFI building. + For this release, please use OpenSSL-1.1.0e. + +4. Build Steps + *** MdeModulePkg *** + 1) Open a terminal and type `"cd ~/src/MyWorkspace"` to enter the workspace + directory. + 2) First build the BaseTools by typing + `"make -C BaseTools"` + 3) Initialize the build environment by typing + `". edksetup.sh"`. + 4) Type following command to build platforms using GCC v5.4.0 <BR> + `"build -p MdeModulePkg/MdeModulePkg.dsc -t GCC5"` + 5) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the ~/src/MyWorkspace/Build/MdeModule/DEBUG_GCC5/IA32 directory +*** + +If you have questions please email the [[edk2-devel]] mail list. + +See also [[Getting Started with EDK II]] + diff --git a/UDK2018-How-to-Build.md b/UDK2018-How-to-Build.md index b981b2162cc4..06a963a8e1e2 100644 --- a/UDK2018-How-to-Build.md +++ b/UDK2018-How-to-Build.md @@ -1,128 +1,134 @@ -# How to Build [[UDK2018]] -Table of Contents -1) [HOW TO BUILD (WINDOWS SYSTEM)](#how-to-build-windows-system) -2) [ HOW TO BUILD (LINUX-LIKE SYSTEM)](#how-to-build-linux-like-system) - -## HOW TO BUILD (WINDOWS SYSTEM) - -The steps below are verified on Microsoft Windows 10 Enterprise*: - -1. Setup Build Environment - 1) Install Microsoft Visual Studio 2015* in the build machine and make - sure that AMD64 complier was selected when installing. - 2) Download NASM 2.12.01 or later from http://www.nasm.us/ and install it to - C:\Nasm. Make sure C:\Nasm is added to system environment variable 'PATH' - 3) Set up for using GitHub for Windows. See: - https://github.com/tianocore/tianocore.github.io/wiki/Getting-Started-with-EDK-II#github-help - 4) Download and install Python2.7.x https://www.python.org/ for building the BaseTools - Default install directory is: C:/Python27 - 5) Download the pre-compiled Openssl binary from https://wiki.openssl.org/index.php/Binaries. Search for a - Windows binary in the list of "_Third Party OpenSSL Related Binary Distributions_" table that will be - Windows binary. Go to the third party site to download the latest version of Windows x64 86 or Win32 binary. - Download and extract to C:\Openssl. Make sure C:\Openssl is added to system environment - variable 'PATH'. - -2. Create the full Source Code directory for the UDK2018 release - 1) Create a working space directory in the build machine, for example, C:\MyWorkspace - 2) Download the official UDK2018 release .zip file from the [UDK2018 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2018) - 1) Download - UDK2018 edk-vUDK2018 Workspace [Source code (zip file)](https://github.com/tianocore/edk2/archive/vUDK2018.zip) - 2) Extract files in [edk2-vUDK2018] to the working space directory C:\MyWorkspace. - 3) **OR** Checkout the vUDK2018 Tag from GitHub with the following "git" command <br> - 1) run `git clone https://github.com/tianocore/edk2.git vUDK2018` - 2) Go to the vUDK2018 directory, and from there run: `git checkout tags/vUDK2018 -b vUDK2018` - 3) Move all files and folders under "vUDK2018" to "C:\MyWorkspace" - -3. Generate OpenSSL* Crypto Library - 1) Open file "C:\MyWorkspace\CryptoPkg\Library\OpensslLib\OpenSSL-HOWTO.txt" - and follow the instruction to install OpenSSL* for UEFI building. - For this release, please use OpenSSL-1.1.0g. Download it from - https://github.com/openssl/openssl/archive/OpenSSL_1_1_0g.zip - Extract it to C:\MyWorkspace\CryptoPkg\Library\OpensslLib, - and rename its directory name to openssl - -4. Compile the BaseTools See: - https://github.com/tianocore/tianocore.github.io/wiki/Windows-systems#compile-tools - 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` - to enter the workspace directory - 2) Compile the BaseTools C source tools -<pre> - set PYTHON_HOME=C:\Python27 - edksetup.bat Rebuild -</pre> - -5. Build Steps - *** NT32 *** - - 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` - to enter the workspace directory - 2) Use edksetup.bat command to initialize the working environment. - `edksetup --nt32` - 3) Type following command to build Nt32 platform - `build -t VS2015x86` - 4) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the C:\MyWorkspace\Build\NT32IA32\DEBUG_VS2015x86\IA32 directory - - ---- - -## HOW TO BUILD (LINUX-LIKE SYSTEM) -The below steps are verified on Ubuntu 16.04 LTS Desktop*: - -1. Setup Build Environment - 1) Follow instructions for setting up the build environment on tianocore.org. - "https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC" - - 2) Please notice that here the root is `"~/src/MyWorkspace`" instead - of `"~/src/edk2"` - - 3) Make sure BaseTools is built and required software like iASL compiler - is installed well. - a) Some operations need switch to user "root" to execute. - b) At Ubuntu, you can type `"sudo apt-get install git"` under terminal "Cnt-Alt-T" to - install git. - 2) Install NASM 2.12.01 or later. - At Ubuntu, you can type "sudo apt-get install nasm" under terminal to - install it. - You can also download the source package from http://www.nasm.us/ and - install it following the instruction on the website. - 3) Install IASL 20150818 or later. - At Ubuntu, you can type `"sudo apt-get install iasl"` under terminal to - install it. - You can also download the source package from https://acpica.org/downloads - and install it following the instruction on the website. - -2. Create the full Source Code directory for the UDK2018 release - 1) Create a working space directory in the build machine, for example, ~/src/MyWorkspace - 2) Download the official UDK2018 release .tar file from the [UDK2018 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2018) - 1) Download - UDK2018 edk-vUDK2018 Workspace [Source code (tar.gz file)](https://github.com/tianocore/edk2/archive/vUDK2018.tar.gz) - 2) Extract files in [edk2-vUDK2018] to the working space directory ~/src/MyWorkspace. - 3) **OR** Checkout the vUDK2018 tag from GitHub with the following "git" command - 1) Run `"git clone https://github.com/tianocore/edk2.git vUDK2018"` - 2) Go to the vUDK2018 directory, and from there run: `git checkout tags/vUDK2018 -b vUDK2018` - 3) Move all files and folders under "vUDK2018" to "~/src/MyWorkspace" - -3. Generate OpenSSL* Crypto Library - 1) Open file "~/src/MyWorkspace/CryptoPkg/Library/OpensslLib/OpenSSL-HOWTO.txt" - and follow the instruction to install OpenSSL* for UEFI building. - For this release, please use OpenSSL-1.1.0g. Download it from - https://github.com/openssl/openssl/archive/OpenSSL_1_1_0g.zip - Extract it to ~/src/MyWorkspace/CryptoPkg/Library/OpensslLib, - and rename its directory name to openssl - - -4. Build Steps - *** MdeModulePkg *** - 1) Open a terminal and type `"cd ~/src/MyWorkspace"` to enter the workspace - directory. - 2) First build the BaseTools by typing - `"make -C BaseTools"` - 3) Initialize the build environment by typing - `". edksetup.sh"`. - 4) Type following command to build platforms using GCC v5.4.0 <BR> - `"build -p MdeModulePkg/MdeModulePkg.dsc -t GCC5"` - 5) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the ~/src/MyWorkspace/Build/MdeModule/DEBUG_GCC5/IA32 directory -*** - -If you have questions please email the [[edk2-devel]] mail list. - -See also [[Getting Started with EDK II]] - +# How to Build [[UDK2018]] + +> Note: New build instructions are available. It is recommended to start with the new instructions if learning how to +> build edk2 for the first time and not specifically targeting UDK2018. This page is retained for reference. + +New instructions: [Build Instructions](Build-Instructions.md) + +Table of Contents +1) [HOW TO BUILD (WINDOWS SYSTEM)](#how-to-build-windows-system) +2) [ HOW TO BUILD (LINUX-LIKE SYSTEM)](#how-to-build-linux-like-system) + +## HOW TO BUILD (WINDOWS SYSTEM) + +The steps below are verified on Microsoft Windows 10 Enterprise*: + +1. Setup Build Environment + 1) Install Microsoft Visual Studio 2015* in the build machine and make + sure that AMD64 complier was selected when installing. + 2) Download NASM 2.12.01 or later from http://www.nasm.us/ and install it to + C:\Nasm. Make sure C:\Nasm is added to system environment variable 'PATH' + 3) Set up for using GitHub for Windows. See: + https://github.com/tianocore/tianocore.github.io/wiki/Getting-Started-with-EDK-II#github-help + 4) Download and install Python2.7.x https://www.python.org/ for building the BaseTools + Default install directory is: C:/Python27 + 5) Download the pre-compiled Openssl binary from https://wiki.openssl.org/index.php/Binaries. Search for a + Windows binary in the list of "_Third Party OpenSSL Related Binary Distributions_" table that will be + Windows binary. Go to the third party site to download the latest version of Windows x64 86 or Win32 binary. + Download and extract to C:\Openssl. Make sure C:\Openssl is added to system environment + variable 'PATH'. + +2. Create the full Source Code directory for the UDK2018 release + 1) Create a working space directory in the build machine, for example, C:\MyWorkspace + 2) Download the official UDK2018 release .zip file from the [UDK2018 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2018) + 1) Download - UDK2018 edk-vUDK2018 Workspace [Source code (zip file)](https://github.com/tianocore/edk2/archive/vUDK2018.zip) + 2) Extract files in [edk2-vUDK2018] to the working space directory C:\MyWorkspace. + 3) **OR** Checkout the vUDK2018 Tag from GitHub with the following "git" command <br> + 1) run `git clone https://github.com/tianocore/edk2.git vUDK2018` + 2) Go to the vUDK2018 directory, and from there run: `git checkout tags/vUDK2018 -b vUDK2018` + 3) Move all files and folders under "vUDK2018" to "C:\MyWorkspace" + +3. Generate OpenSSL* Crypto Library + 1) Open file "C:\MyWorkspace\CryptoPkg\Library\OpensslLib\OpenSSL-HOWTO.txt" + and follow the instruction to install OpenSSL* for UEFI building. + For this release, please use OpenSSL-1.1.0g. Download it from + https://github.com/openssl/openssl/archive/OpenSSL_1_1_0g.zip + Extract it to C:\MyWorkspace\CryptoPkg\Library\OpensslLib, + and rename its directory name to openssl + +4. Compile the BaseTools See: + https://github.com/tianocore/tianocore.github.io/wiki/Windows-systems#compile-tools + 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` + to enter the workspace directory + 2) Compile the BaseTools C source tools +<pre> + set PYTHON_HOME=C:\Python27 + edksetup.bat Rebuild +</pre> + +5. Build Steps + *** NT32 *** + + 1) Open a Microsoft Visual Studio* command prompt, type `cd C:\MyWorkspace` + to enter the workspace directory + 2) Use edksetup.bat command to initialize the working environment. + `edksetup --nt32` + 3) Type following command to build Nt32 platform + `build -t VS2015x86` + 4) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the C:\MyWorkspace\Build\NT32IA32\DEBUG_VS2015x86\IA32 directory + + +--- + +## HOW TO BUILD (LINUX-LIKE SYSTEM) +The below steps are verified on Ubuntu 16.04 LTS Desktop*: + +1. Setup Build Environment + 1) Follow instructions for setting up the build environment on tianocore.org. + "https://github.com/tianocore/tianocore.github.io/wiki/Using-EDK-II-with-Native-GCC" + + 2) Please notice that here the root is `"~/src/MyWorkspace`" instead + of `"~/src/edk2"` + + 3) Make sure BaseTools is built and required software like iASL compiler + is installed well. + a) Some operations need switch to user "root" to execute. + b) At Ubuntu, you can type `"sudo apt-get install git"` under terminal "Cnt-Alt-T" to + install git. + 2) Install NASM 2.12.01 or later. + At Ubuntu, you can type "sudo apt-get install nasm" under terminal to + install it. + You can also download the source package from http://www.nasm.us/ and + install it following the instruction on the website. + 3) Install IASL 20150818 or later. + At Ubuntu, you can type `"sudo apt-get install iasl"` under terminal to + install it. + You can also download the source package from https://acpica.org/downloads + and install it following the instruction on the website. + +2. Create the full Source Code directory for the UDK2018 release + 1) Create a working space directory in the build machine, for example, ~/src/MyWorkspace + 2) Download the official UDK2018 release .tar file from the [UDK2018 Release Page](https://github.com/tianocore/edk2/releases/tag/vUDK2018) + 1) Download - UDK2018 edk-vUDK2018 Workspace [Source code (tar.gz file)](https://github.com/tianocore/edk2/archive/vUDK2018.tar.gz) + 2) Extract files in [edk2-vUDK2018] to the working space directory ~/src/MyWorkspace. + 3) **OR** Checkout the vUDK2018 tag from GitHub with the following "git" command + 1) Run `"git clone https://github.com/tianocore/edk2.git vUDK2018"` + 2) Go to the vUDK2018 directory, and from there run: `git checkout tags/vUDK2018 -b vUDK2018` + 3) Move all files and folders under "vUDK2018" to "~/src/MyWorkspace" + +3. Generate OpenSSL* Crypto Library + 1) Open file "~/src/MyWorkspace/CryptoPkg/Library/OpensslLib/OpenSSL-HOWTO.txt" + and follow the instruction to install OpenSSL* for UEFI building. + For this release, please use OpenSSL-1.1.0g. Download it from + https://github.com/openssl/openssl/archive/OpenSSL_1_1_0g.zip + Extract it to ~/src/MyWorkspace/CryptoPkg/Library/OpensslLib, + and rename its directory name to openssl + + +4. Build Steps + *** MdeModulePkg *** + 1) Open a terminal and type `"cd ~/src/MyWorkspace"` to enter the workspace + directory. + 2) First build the BaseTools by typing + `"make -C BaseTools"` + 3) Initialize the build environment by typing + `". edksetup.sh"`. + 4) Type following command to build platforms using GCC v5.4.0 <BR> + `"build -p MdeModulePkg/MdeModulePkg.dsc -t GCC5"` + 5) Upon the build completing successfully there should be the UEFI Application "`HelloWorld.efi`" in the ~/src/MyWorkspace/Build/MdeModule/DEBUG_GCC5/IA32 directory +*** + +If you have questions please email the [[edk2-devel]] mail list. + +See also [[Getting Started with EDK II]] + diff --git a/Unix-like-systems.mediawiki b/Unix-like-systems.mediawiki index 36fd1a2b1299..1d037b51513a 100644 --- a/Unix-like-systems.mediawiki +++ b/Unix-like-systems.mediawiki @@ -1,210 +1,215 @@ -This page provides ''step-by-step instructions'' for setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on various Unix-like systems. - -'''Note''': These instructions are not recommended for most EDK II developers. If you are working with a supported Linux distribution, then the [[Using EDK II with Native GCC]] instructions are faster, easier, and produce a smaller UEFI binary image. - -==Getting started for UNIX-like operating systems== - -These instructions will be written as a series of commands executed from a command terminal. - -Often these instructions will contain a command which needs to be executed in the terminal window. For example: - -<pre> -bash$ echo this bold text is a sample command -</pre> - -To execute this command, highlight the bold text of the command in your web browser. Most web browsers should be able to copy the text by selecting Copy under the Edit menu. Now, change back to the terminal application, and there should be a Paste operation under the Edit menu. After pasting the command into the shell, you may need to press the enter or return key to execute the command. - -Of course, there may be other ways to copy and paste the command into the terminal which are specific to the windowing environment and applications that you are using. If all else fails, however, you can type the command by hand. - -Some commands are very long, and we use the backslash character (\) to tell the shell program that the command is not finished. For example: - -<pre> -bash$ echo this bold text is a sample command \ - which is broken into two lines -</pre> - -When you copy and paste, make sure you include all lines of the command (including the backslash (\) characters). If you are typing the command, you can remove the backslash character (\) and combine the lines into a single line if you prefer. - -If a command starts with the sudo command, then you may be prompted for your user password. This will be the same password as you used to login to the system. - -For the purposes of this set of instructions, we will be using the following paths. -{| -|Edk2 source tree: || ~/src/edk2 -|- -|GCC X64 cross-compiler installation: || ~/programs/gcc/x64 -|- -|GCC IA32 cross-compiler installation: || ~/programs/gcc/ia32 -|- -|Intel ASL Compiler installation: || ~/src/acpica-unix-20090521/compiler/iasl (symlink to compiler at ~/programs/iasl) -|} - -You will need to change the commands if you want to use different locations, but this is not recommended unless you are sure that you know what you are doing. - -===Internet proxies=== - -If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common examples of how you would configure your proxy by setting an environment variable: - -<pre> -bash$ export http_proxy=http://proxy.domain.com:proxy_port -bash$ export ftp_proxy=$http_proxy -</pre> - -To utilize the subversion source control command behind an internet firewall with a web proxy, you should configure the ~/.subversion/servers file. - -== Cygwin 1.7.1 == -Notes: -* Cygwin is not officially supported or tested by the edk2 project at this time. -* Building of [http://www.tianocore.org/edk2/ EDK II] components will be done using bash. -Prerequisites: -* Cygwin 1.7.1 is currently installed on the system. -* Cygwin 1.7.1 setup.exe is available on the system to install additional packages as needed. - -Run Cygwin setup.exe and install the following additional packages. -* bison -* flex -* libgmp-devel -* libiconv -* libmpfr-devel -* gcc (use the compiler upgrade helper option under Devel) -* make -* python -* subversion -* wget -* libuuid-devel -* util-linux (for uuidgen) - -When pulling source files using subversion you may choose to get them to a more Windows friendly location. All system drives are mapped under /cygdrive when using CYGWIN and bash (ie. C:\ maps to /cygdrive/c). This allows you to substitute ~/src/edk2 for an alternate path such as /cygdrive/c/src/edk2 so files can be access at C:\src\edk2 as well. - -<big> -Continue with common instructions for Unix -</big> - -The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. - -==Fedora 11== -Please note: -* Fedora 11 is not officially supported or tested by the edk2 project at this time. -* These instructions assume that the Software Development option was enabled during the Fedora installation. - -===Open the GNOME Terminal program=== - -These instructions will utilize Fedora's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. - -===Install MPFR library=== - -The MPFR library must be installed to allow the gcc cross compiler to be built. - -<pre> -bash$ mkdir ~/src -bash$ cd ~/src -bash$ wget http://www.mpfr.org/mpfr-current/mpfr-2.4.1.tar.bz2 -bash$ tar -jxf mpfr-2.4.1.tar.bz2 -bash$ cd mpfr-2.4.1 -bash$ ./configure --prefix=/usr -bash$ make -</pre> - -To install the library, you must be root. Therefore we use 'su' to become the root user, for the 'make install' command. - -<pre> -bash$ su -bash$ make install -bash$ exit -</pre> - -<big> -Continue with common instructions for Unix -</big> - -The [[Common instructions for Unix |remaining instructions]] are common for most UNIX-like systems. - -==Mac OS X 10.5== -===Xcode Tools=== - -The first step is to install the Apple Xcode development environment: - http://developer.apple.com/tools/xcode - -To install Xcode, you must register as an Apple developer, and download the Xcode installation disk image (which is fairly large). These instructions were verified with Xcode 3.0. Within the Xcode Tools disk image, only the Xcode Tools.mpkg package needs to be installed. - -===Open OS X Terminal program=== - -Past this point, the remaining instructions will utilize OS X's built in command shell (bash) via the Terminal application. To open the command terminal application, open Finder, then press the Cmd-Shift-U key combination. (This opens the Applications => Utilities folder.) In the Utilities folder, you should see the Terminal application. - -===GMP & MPFR (if behind a web proxy)=== - -The gmp and mpfr libraries are needed to build the gcc cross compiler at a later point in these instructions. Building these libraries on OS X can present some difficulties, so if you are not behind a network firewall, then consider using the macports project to install these libraries. (see below) Be sure to set the http_proxy and ftp_proxy environment variables before using the 'curl' commands below. - -<pre> -bash$ mkdir ~/src -bash$ cd ~/src -bash$ curl --remote-name \ - ftp://ftp.gnu.org/gnu/gmp/gmp-4.2.2.tar.bz2 -bash$ tar jxvf gmp-4.2.2.tar.bz2 -bash$ cd gmp-4.2.2 -bash$ ./configure --prefix=/usr -bash$ make -bash$ make check -bash$ sudo make install -</pre> - -Note: This might be needed for 64-bit machines if the MPFR configure fails below. -<pre> -bash$ export CFLAGS="-m64" -</pre> - -<pre> -bash$ cd ~/src -bash$ curl --remote-name \ - http://www.mpfr.org/mpfr-current/mpfr-2.4.1.tar.bz2 -bash$ tar -jxf mpfr-2.4.1.tar.bz2 -bash$ cd mpfr-2.4.1 -bash$ ./configure --prefix=/usr -bash$ make -bash$ sudo make install -</pre> - -===GMP & MPFR via Macports (if not behind web proxy)=== - -If you are not behind a network firewall, then the http://www.macports.org project can greatly simlify the installation of gmp & mpfr. (Macports does not work easily with web proxies at this time.) After installing macports you should be able to simply run this command at the shell prompt. - -<pre> -bash$ sudo port install gmp mpfr -</pre> - -<big> -Continue with common instructions for Unix -</big> - -The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. - -<!-- -==Red Hat Enterprise Linux 4 Desktop== -Coming soon... ---> -<!-- -==SuSE Linux Enterprise 10 Desktop== -Coming soon... ---> - -==Ubuntu 9.10== -Note: The Ubuntu platform is not officially supported or tested by the edk2 project at this time. - -===Open the GNOME Terminal program=== - -These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. - -===Install required software from apt=== - -Several ubuntu packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. - -<pre> -bash$ sudo apt-get install build-essential uuid-dev texinfo \ - bison flex libgmp3-dev libmpfr-dev subversion -</pre> - - -==Continue with common instructions for Unix== - - -The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. - + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +This page provides ''step-by-step instructions'' for setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on various Unix-like systems. + +'''Note''': These instructions are not recommended for most EDK II developers. If you are working with a supported Linux distribution, then the [[Using EDK II with Native GCC]] instructions are faster, easier, and produce a smaller UEFI binary image. + +==Getting started for UNIX-like operating systems== + +These instructions will be written as a series of commands executed from a command terminal. + +Often these instructions will contain a command which needs to be executed in the terminal window. For example: + +<pre> +bash$ echo this bold text is a sample command +</pre> + +To execute this command, highlight the bold text of the command in your web browser. Most web browsers should be able to copy the text by selecting Copy under the Edit menu. Now, change back to the terminal application, and there should be a Paste operation under the Edit menu. After pasting the command into the shell, you may need to press the enter or return key to execute the command. + +Of course, there may be other ways to copy and paste the command into the terminal which are specific to the windowing environment and applications that you are using. If all else fails, however, you can type the command by hand. + +Some commands are very long, and we use the backslash character (\) to tell the shell program that the command is not finished. For example: + +<pre> +bash$ echo this bold text is a sample command \ + which is broken into two lines +</pre> + +When you copy and paste, make sure you include all lines of the command (including the backslash (\) characters). If you are typing the command, you can remove the backslash character (\) and combine the lines into a single line if you prefer. + +If a command starts with the sudo command, then you may be prompted for your user password. This will be the same password as you used to login to the system. + +For the purposes of this set of instructions, we will be using the following paths. +{| +|Edk2 source tree: || ~/src/edk2 +|- +|GCC X64 cross-compiler installation: || ~/programs/gcc/x64 +|- +|GCC IA32 cross-compiler installation: || ~/programs/gcc/ia32 +|- +|Intel ASL Compiler installation: || ~/src/acpica-unix-20090521/compiler/iasl (symlink to compiler at ~/programs/iasl) +|} + +You will need to change the commands if you want to use different locations, but this is not recommended unless you are sure that you know what you are doing. + +===Internet proxies=== + +If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common examples of how you would configure your proxy by setting an environment variable: + +<pre> +bash$ export http_proxy=http://proxy.domain.com:proxy_port +bash$ export ftp_proxy=$http_proxy +</pre> + +To utilize the subversion source control command behind an internet firewall with a web proxy, you should configure the ~/.subversion/servers file. + +== Cygwin 1.7.1 == +Notes: +* Cygwin is not officially supported or tested by the edk2 project at this time. +* Building of [http://www.tianocore.org/edk2/ EDK II] components will be done using bash. +Prerequisites: +* Cygwin 1.7.1 is currently installed on the system. +* Cygwin 1.7.1 setup.exe is available on the system to install additional packages as needed. + +Run Cygwin setup.exe and install the following additional packages. +* bison +* flex +* libgmp-devel +* libiconv +* libmpfr-devel +* gcc (use the compiler upgrade helper option under Devel) +* make +* python +* subversion +* wget +* libuuid-devel +* util-linux (for uuidgen) + +When pulling source files using subversion you may choose to get them to a more Windows friendly location. All system drives are mapped under /cygdrive when using CYGWIN and bash (ie. C:\ maps to /cygdrive/c). This allows you to substitute ~/src/edk2 for an alternate path such as /cygdrive/c/src/edk2 so files can be access at C:\src\edk2 as well. + +<big> +Continue with common instructions for Unix +</big> + +The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. + +==Fedora 11== +Please note: +* Fedora 11 is not officially supported or tested by the edk2 project at this time. +* These instructions assume that the Software Development option was enabled during the Fedora installation. + +===Open the GNOME Terminal program=== + +These instructions will utilize Fedora's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. + +===Install MPFR library=== + +The MPFR library must be installed to allow the gcc cross compiler to be built. + +<pre> +bash$ mkdir ~/src +bash$ cd ~/src +bash$ wget http://www.mpfr.org/mpfr-current/mpfr-2.4.1.tar.bz2 +bash$ tar -jxf mpfr-2.4.1.tar.bz2 +bash$ cd mpfr-2.4.1 +bash$ ./configure --prefix=/usr +bash$ make +</pre> + +To install the library, you must be root. Therefore we use 'su' to become the root user, for the 'make install' command. + +<pre> +bash$ su +bash$ make install +bash$ exit +</pre> + +<big> +Continue with common instructions for Unix +</big> + +The [[Common instructions for Unix |remaining instructions]] are common for most UNIX-like systems. + +==Mac OS X 10.5== +===Xcode Tools=== + +The first step is to install the Apple Xcode development environment: + http://developer.apple.com/tools/xcode + +To install Xcode, you must register as an Apple developer, and download the Xcode installation disk image (which is fairly large). These instructions were verified with Xcode 3.0. Within the Xcode Tools disk image, only the Xcode Tools.mpkg package needs to be installed. + +===Open OS X Terminal program=== + +Past this point, the remaining instructions will utilize OS X's built in command shell (bash) via the Terminal application. To open the command terminal application, open Finder, then press the Cmd-Shift-U key combination. (This opens the Applications => Utilities folder.) In the Utilities folder, you should see the Terminal application. + +===GMP & MPFR (if behind a web proxy)=== + +The gmp and mpfr libraries are needed to build the gcc cross compiler at a later point in these instructions. Building these libraries on OS X can present some difficulties, so if you are not behind a network firewall, then consider using the macports project to install these libraries. (see below) Be sure to set the http_proxy and ftp_proxy environment variables before using the 'curl' commands below. + +<pre> +bash$ mkdir ~/src +bash$ cd ~/src +bash$ curl --remote-name \ + ftp://ftp.gnu.org/gnu/gmp/gmp-4.2.2.tar.bz2 +bash$ tar jxvf gmp-4.2.2.tar.bz2 +bash$ cd gmp-4.2.2 +bash$ ./configure --prefix=/usr +bash$ make +bash$ make check +bash$ sudo make install +</pre> + +Note: This might be needed for 64-bit machines if the MPFR configure fails below. +<pre> +bash$ export CFLAGS="-m64" +</pre> + +<pre> +bash$ cd ~/src +bash$ curl --remote-name \ + http://www.mpfr.org/mpfr-current/mpfr-2.4.1.tar.bz2 +bash$ tar -jxf mpfr-2.4.1.tar.bz2 +bash$ cd mpfr-2.4.1 +bash$ ./configure --prefix=/usr +bash$ make +bash$ sudo make install +</pre> + +===GMP & MPFR via Macports (if not behind web proxy)=== + +If you are not behind a network firewall, then the http://www.macports.org project can greatly simlify the installation of gmp & mpfr. (Macports does not work easily with web proxies at this time.) After installing macports you should be able to simply run this command at the shell prompt. + +<pre> +bash$ sudo port install gmp mpfr +</pre> + +<big> +Continue with common instructions for Unix +</big> + +The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. + +<!-- +==Red Hat Enterprise Linux 4 Desktop== +Coming soon... +--> +<!-- +==SuSE Linux Enterprise 10 Desktop== +Coming soon... +--> + +==Ubuntu 9.10== +Note: The Ubuntu platform is not officially supported or tested by the edk2 project at this time. + +===Open the GNOME Terminal program=== + +These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. + +===Install required software from apt=== + +Several ubuntu packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. + +<pre> +bash$ sudo apt-get install build-essential uuid-dev texinfo \ + bison flex libgmp3-dev libmpfr-dev subversion +</pre> + + +==Continue with common instructions for Unix== + + +The [[Common instructions for Unix|remaining instructions]] are common for most UNIX-like systems. + diff --git a/Using-EDK-II-with-Native-GCC.mediawiki b/Using-EDK-II-with-Native-GCC.mediawiki index e17f5056b446..ea8c8f9326dc 100644 --- a/Using-EDK-II-with-Native-GCC.mediawiki +++ b/Using-EDK-II-with-Native-GCC.mediawiki @@ -1,241 +1,244 @@ - - -This page provides ''step-by-step instructions'' for setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on Linux using a native GCC installation (4.4+). This EDK II setup does not require the Mingw version of GCC to be built, and therefore can be much faster to setup. - -==Getting Started== - -These instructions will be written as a series of commands executed from a command terminal.Often these instructions will contain a command which needs to be executed in the terminal window. For example: - -<pre> -bash$ echo this text is a sample command -</pre> - -To execute this command, highlight the text of the command in your web browser. (Note that the 'bash$' text is not part of the command!) Most web browsers should be able to copy the text by selecting Copy under the Edit menu. Now, change back to the terminal application, and there should be a Paste operation under the Edit menu. After pasting the command into the shell, you may need to press the enter or return key to execute the command. - -Of course, there may be other ways to copy and paste the command into the terminal which are specific to the windowing environment and applications that you are using. If all else fails, however, you can type the command by hand. - -Some commands are very long, and we use the backslash character (\) to tell the shell program that the command is not finished. For example: - -<pre> -bash$ echo this bold text is a sample command \ - which is broken into two lines -</pre> - -When you copy and paste, make sure you include all lines of the command (including the backslash (\) characters). If you are typing the command, you can remove the backslash character (\) and combine the lines into a single line if you prefer. - -If a command starts with the sudo command, then you may be prompted for your user password. This will be the same password as you used to login to the system. - -For the purposes of this set of instructions, we will be using the following paths. -{| -|Edk2 source tree: || $HOME/src/edk2 -|- -|Native GCC 4.x compiler installation: || /usr/bin/gcc -|- -|Intel ASL Compiler installation: || /usr/bin/iasl -|} - -You will need to change the commands if you want to use different locations, but this is not recommended unless you are sure that you know what you are doing. - -===Internet proxies=== - -If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common examples of how you would configure your proxy by setting an environment variable: - -<pre> -bash$ export http_proxy=http://proxy.domain.com:proxy_port -bash$ export ftp_proxy=$http_proxy -</pre> - -To utilize the subversion source control command behind an internet firewall with a web proxy, you should configure the ~/.subversion/servers file. - -===Ubuntu 20.04 LTS=== - -Note: These instructions utilize GCC5 & NASM compiler support (added in early 2016), along with git (replaces subversion). GCC 4.x is still supported. GCC5 is not mandatory. - -====Open the GNOME Terminal program==== - -These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. - -====Install required software from apt==== - -Several Ubuntu packages will be needed to set up the build environment for EDK II. The following command will install all required packages: - -<pre> -bash$ sudo apt install build-essential uuid-dev iasl git nasm python-is-python3 -</pre> - -:build-essential - Informational list of build-essential packages -:uuid-dev - Universally Unique ID library (headers and static libraries) -:iasl - Intel ASL compiler/decompiler (also provided by acpica-tools) -:git - support for git revision control system -:nasm - General-purpose x86 assembler -:python-is-python3 - Ubuntu 20.04 python command is 'python3' but edk2 tools use 'python' - - -===Continue with common instructions=== - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - - - -===Ubuntu 16.04 LTS / Ubuntu 16.10=== - -Note: These instructions utilize GCC5 & NASM compiler support (added in early 2016), along with git (replaces subversion). GCC 4.x is still supported. GCC5 is not mandatory. - -====Open the GNOME Terminal program==== - -These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. - -====Install required software from apt==== - -Several Ubuntu packages will be needed to set up the build environment for EDK II. The following command will install all required packages: - -<pre> -bash$ sudo apt-get install build-essential uuid-dev iasl git gcc-5 nasm python3-distutils -</pre> - -:build-essential - Informational list of build-essential packages -:uuid-dev - Universally Unique ID library (headers and static libraries) -:iasl - Intel ASL compiler/decompiler (also provided by acpica-tools) -:git - support for git revision control system -:gcc-5 - GNU C compiler (v5.4.0 as of Ubuntu 16.04 LTS) -:nasm - General-purpose x86 assembler -:python3-distutils - distutils module from the Python standard library - -===Continue with common instructions=== - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - - -==Instructions for older Linux Environments== - -Note: the instructions below have not been updated for compilers newer than GCC 4.4, git (replaces subversion) or NASM. Newer builds may fail without satisfying these dependecies. We recommend moving to newer Linux distributions unless you have a dependency on a specific version. - -===Note: Limitations of GCC 4.4=== - -Note: The GCC 4.4 toolchain only supports building images for the IA32 and X64 architectures. We recommend using newer toolchains. - -Also, in some cases if GCC 4.4 is installed under Linux x86 (32-bit mode), then it may only support building UEFI images for the IA32 architecture. - -===Arch Linux 2010.05=== -Note: Arch Linux is not officially supported or tested by the edk2 project at this time. - -====Open the GNOME Terminal program==== - -These instructions will utilize Arch Linux's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. - -====Install required software with pacman==== - -To install the required packages, you must be root. Therefore we use 'su' to become the root user. - -<pre> -bash$ su - -bash$ pacman -S base-devel glibc iasl python2 subversion -bash$ exit -</pre> - -<big> -Continue with common instructions -</big> - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - -===Fedora 13=== -Note: Fedora is not officially supported or tested by the edk2 project at this time. - -Note: x86 (32-bit) Fedora will install GCC 4.4 which is only capable of building UEFI for the IA32 architecture. - -====Open the GNOME Terminal program==== - -These instructions will utilize Fedora's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. - -====Install required software with yum==== - -To install the required packages, you must be root. Therefore we use 'su' to become the root user. - -<pre> -bash$ su - -bash$ yum groupinstall development-tools -bash$ yum install iasl libuuid-devel -bash$ exit -</pre> - -<big> -Continue with common instructions -</big> - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - -===Mandriva 2010=== -Note: Mandriva is not officially supported or tested by the edk2 project at this time. - -Note: x86 (32-bit) Mandriva will install GCC 4.4 which is only capable of building UEFI for the IA32 architecture. - -====Open the Terminal program==== - -These instructions will utilize Mandriva's built in command shell (bash) via the Terminal application. To open the Terminal application, locate it under the Applications menu and the Tools sub-menu. - -====Install required software with urpmi==== - -To install the required packages, you must be root. Therefore we use 'su' to become the root user. - -<pre> -bash$ su - -bash$ urpmi task-c++-devel iasl libuuid-devel subversion -bash$ exit -</pre> - -<big> -Continue with common instructions -</big> - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - -===openSUSE 12.1=== - -Note: openSUSE is not officially supported or tested by the edk2 project at this time. - -====Open the GNOME Terminal program==== - -These instructions will utilize openSUSE's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, click the 'Computer' menu, click the 'More Applications' button, and then enter 'terminal' into the filter text box. - -====Install required software with zypper==== - -Several openSUSE packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. - -<pre> -bash> sudo zypper in -t pattern devel_basis -</pre> - -<big> -Continue with common instructions -</big> - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - -===Ubuntu 10.10=== -Notes: -* The Ubuntu platform is not officially supported or tested by the edk2 project at this time. -* Both the x86 (32-bit) and x86-64 (64-bit) Ubuntu versions will install GCC 4.4 which is capable of building UEFI for both the IA32 and X64 architectures. -* These instructions should work for Ubuntu 10.04 as well - -====Open the GNOME Terminal program==== - -These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. - -====Install required software from apt==== - -Several ubuntu packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. - -<pre> -bash$ sudo apt-get install build-essential subversion uuid-dev iasl -</pre> - - -===Continue with common instructions=== - -The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. - - -=See Also= - + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +This page provides ''step-by-step instructions'' for setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on Linux using a native GCC installation (4.4+). This EDK II setup does not require the Mingw version of GCC to be built, and therefore can be much faster to setup. + +==Getting Started== + +These instructions will be written as a series of commands executed from a command terminal.Often these instructions will contain a command which needs to be executed in the terminal window. For example: + +<pre> +bash$ echo this text is a sample command +</pre> + +To execute this command, highlight the text of the command in your web browser. (Note that the 'bash$' text is not part of the command!) Most web browsers should be able to copy the text by selecting Copy under the Edit menu. Now, change back to the terminal application, and there should be a Paste operation under the Edit menu. After pasting the command into the shell, you may need to press the enter or return key to execute the command. + +Of course, there may be other ways to copy and paste the command into the terminal which are specific to the windowing environment and applications that you are using. If all else fails, however, you can type the command by hand. + +Some commands are very long, and we use the backslash character (\) to tell the shell program that the command is not finished. For example: + +<pre> +bash$ echo this bold text is a sample command \ + which is broken into two lines +</pre> + +When you copy and paste, make sure you include all lines of the command (including the backslash (\) characters). If you are typing the command, you can remove the backslash character (\) and combine the lines into a single line if you prefer. + +If a command starts with the sudo command, then you may be prompted for your user password. This will be the same password as you used to login to the system. + +For the purposes of this set of instructions, we will be using the following paths. +{| +|Edk2 source tree: || $HOME/src/edk2 +|- +|Native GCC 4.x compiler installation: || /usr/bin/gcc +|- +|Intel ASL Compiler installation: || /usr/bin/iasl +|} + +You will need to change the commands if you want to use different locations, but this is not recommended unless you are sure that you know what you are doing. + +===Internet proxies=== + +If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common examples of how you would configure your proxy by setting an environment variable: + +<pre> +bash$ export http_proxy=http://proxy.domain.com:proxy_port +bash$ export ftp_proxy=$http_proxy +</pre> + +To utilize the subversion source control command behind an internet firewall with a web proxy, you should configure the ~/.subversion/servers file. + +===Ubuntu 20.04 LTS=== + +Note: These instructions utilize GCC5 & NASM compiler support (added in early 2016), along with git (replaces subversion). GCC 4.x is still supported. GCC5 is not mandatory. + +====Open the GNOME Terminal program==== + +These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. + +====Install required software from apt==== + +Several Ubuntu packages will be needed to set up the build environment for EDK II. The following command will install all required packages: + +<pre> +bash$ sudo apt install build-essential uuid-dev iasl git nasm python-is-python3 +</pre> + +:build-essential - Informational list of build-essential packages +:uuid-dev - Universally Unique ID library (headers and static libraries) +:iasl - Intel ASL compiler/decompiler (also provided by acpica-tools) +:git - support for git revision control system +:nasm - General-purpose x86 assembler +:python-is-python3 - Ubuntu 20.04 python command is 'python3' but edk2 tools use 'python' + + +===Continue with common instructions=== + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + + + +===Ubuntu 16.04 LTS / Ubuntu 16.10=== + +Note: These instructions utilize GCC5 & NASM compiler support (added in early 2016), along with git (replaces subversion). GCC 4.x is still supported. GCC5 is not mandatory. + +====Open the GNOME Terminal program==== + +These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. + +====Install required software from apt==== + +Several Ubuntu packages will be needed to set up the build environment for EDK II. The following command will install all required packages: + +<pre> +bash$ sudo apt-get install build-essential uuid-dev iasl git gcc-5 nasm python3-distutils +</pre> + +:build-essential - Informational list of build-essential packages +:uuid-dev - Universally Unique ID library (headers and static libraries) +:iasl - Intel ASL compiler/decompiler (also provided by acpica-tools) +:git - support for git revision control system +:gcc-5 - GNU C compiler (v5.4.0 as of Ubuntu 16.04 LTS) +:nasm - General-purpose x86 assembler +:python3-distutils - distutils module from the Python standard library + +===Continue with common instructions=== + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + + +==Instructions for older Linux Environments== + +Note: the instructions below have not been updated for compilers newer than GCC 4.4, git (replaces subversion) or NASM. Newer builds may fail without satisfying these dependecies. We recommend moving to newer Linux distributions unless you have a dependency on a specific version. + +===Note: Limitations of GCC 4.4=== + +Note: The GCC 4.4 toolchain only supports building images for the IA32 and X64 architectures. We recommend using newer toolchains. + +Also, in some cases if GCC 4.4 is installed under Linux x86 (32-bit mode), then it may only support building UEFI images for the IA32 architecture. + +===Arch Linux 2010.05=== +Note: Arch Linux is not officially supported or tested by the edk2 project at this time. + +====Open the GNOME Terminal program==== + +These instructions will utilize Arch Linux's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. + +====Install required software with pacman==== + +To install the required packages, you must be root. Therefore we use 'su' to become the root user. + +<pre> +bash$ su - +bash$ pacman -S base-devel glibc iasl python2 subversion +bash$ exit +</pre> + +<big> +Continue with common instructions +</big> + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + +===Fedora 13=== +Note: Fedora is not officially supported or tested by the edk2 project at this time. + +Note: x86 (32-bit) Fedora will install GCC 4.4 which is only capable of building UEFI for the IA32 architecture. + +====Open the GNOME Terminal program==== + +These instructions will utilize Fedora's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the System Tools sub-menu. + +====Install required software with yum==== + +To install the required packages, you must be root. Therefore we use 'su' to become the root user. + +<pre> +bash$ su - +bash$ yum groupinstall development-tools +bash$ yum install iasl libuuid-devel +bash$ exit +</pre> + +<big> +Continue with common instructions +</big> + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + +===Mandriva 2010=== +Note: Mandriva is not officially supported or tested by the edk2 project at this time. + +Note: x86 (32-bit) Mandriva will install GCC 4.4 which is only capable of building UEFI for the IA32 architecture. + +====Open the Terminal program==== + +These instructions will utilize Mandriva's built in command shell (bash) via the Terminal application. To open the Terminal application, locate it under the Applications menu and the Tools sub-menu. + +====Install required software with urpmi==== + +To install the required packages, you must be root. Therefore we use 'su' to become the root user. + +<pre> +bash$ su - +bash$ urpmi task-c++-devel iasl libuuid-devel subversion +bash$ exit +</pre> + +<big> +Continue with common instructions +</big> + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + +===openSUSE 12.1=== + +Note: openSUSE is not officially supported or tested by the edk2 project at this time. + +====Open the GNOME Terminal program==== + +These instructions will utilize openSUSE's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, click the 'Computer' menu, click the 'More Applications' button, and then enter 'terminal' into the filter text box. + +====Install required software with zypper==== + +Several openSUSE packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. + +<pre> +bash> sudo zypper in -t pattern devel_basis +</pre> + +<big> +Continue with common instructions +</big> + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + +===Ubuntu 10.10=== +Notes: +* The Ubuntu platform is not officially supported or tested by the edk2 project at this time. +* Both the x86 (32-bit) and x86-64 (64-bit) Ubuntu versions will install GCC 4.4 which is capable of building UEFI for both the IA32 and X64 architectures. +* These instructions should work for Ubuntu 10.04 as well + +====Open the GNOME Terminal program==== + +These instructions will utilize Ubuntu's built in command shell (bash) via the GNOME Terminal application. To open the Terminal application, locate it under the Applications menu and the Accessories sub-menu. + +====Install required software from apt==== + +Several ubuntu packages will be needed to fully set up an edk2 build environment. In order to easily install all the requirements, you need to run this command. + +<pre> +bash$ sudo apt-get install build-essential subversion uuid-dev iasl +</pre> + + +===Continue with common instructions=== + +The [[Common instructions|remaining instructions]] are common for most UNIX-like systems. + + +=See Also= + * [[Unix-like systems]] - Instructions which walk through building the Mingw GCC cross-compiler \ No newline at end of file diff --git a/Windows-systems.mediawiki b/Windows-systems.mediawiki index ebb717a22464..6be6e9187be8 100644 --- a/Windows-systems.mediawiki +++ b/Windows-systems.mediawiki @@ -1,156 +1,162 @@ -__NOTOC__ -This page provides step-by-step instructions or setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on Windows systems. - -<u>''Table of Contents''</u> -* [[Windows-systems#github-help|GitHub Help]] -* [[Windows-systems#how-to-setup-the-edk-ii-tree| How to Setup the EDK II Tree]] -* [[Windows-systems#download| Download]] Checkout EDK II source tree from Github -* [[Windows-systems#compile-tools |Compile Tools]] Build EDK II BaseTools for Windows -* [[Windows-systems#build | BUILD]] EDK II - -==GitHub Help== - -GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub. - -=== Git GUI Interface for Windows OS === -* Git for Windows OS is available at: (http://git-scm.com/download/win) -* TortoiseGit for windows OS is available at (https://tortoisegit.org/download/) - -=='''GitHub EDK II Project Repositories'''== - -* The EDK II project repository is available at https://github.com/tianocore/edk2. - -Content that is not released under an accepted open source license can be found at https://github.com/tianocore/edk2-non-osi.<br /> - <br /> -Note: the steps below will pull the latest code from edk2 master. To work from a stable release, please refer to the Microsoft Windows build steps for [[UDK2017]]: https://github.com/tianocore/tianocore.github.io/wiki/UDK2017-How-to-Build#how-to-build-windows-system - -===Internet proxies=== - -If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common '''Git Bash''' examples of how you would configure your proxy by setting an environment variable: - -<pre> - $ git config --global https.proxy <proxyname>.domain.com:<port> - $ git config --global http.proxy <proxyname>.domain.com:<port> -</pre> - - -=='''How to Setup the EDK II Tree'''== -'''Note:''' Some of the following examples use the Multiple Workspace feature to configure the EDK II BaseTools. More information on the Multiple Workspace feature can be found at the following location. <BR> -* [[Multiple_Workspace]] - -=='''Download'''== -Download/Checkout the EDK II source tree from Github -=== Download Using a Web browser === - -# Download EDK II Project -## Open https://github.com/tianocore/edk2 in web browser -## Click on the ''Clone or Download'' button (Right Green) -## Click on Download ZIP -## Unzip to C:/ -## Rename directory “edk2-master” to “edk2” - -Continue to [[Windows-systems#compile-tools |Compile Tools]] - -=== Using '''Git for Windows''' Application === -==== ''Git GUI''==== -# Clone the EDK II project repository -## Open Git GUI -## Use ''Clone Exiting Repository'' with Source location https://github.com/tianocore/edk2.git -## Select a Target directory C:/edk2 -## Check Recursively clone submodules too -## click Clone button - -Continue to [[Windows-systems#compile-tools |Compile Tools]] section - -==== ''Git CMD'' ==== -If you use the command line version, then you can easily checkout the edk2 to the C:\edk2 directory with the following git command: -Main repository: https://github.com/tianocore/edk2 -<pre> - $git clone https://github.com/tianocore/edk2 -</pre> - -Continue to [[Windows-systems#compile-tools |Compile Tools]] and then [[Windows-systems#build | BUILD]] sections - -=='''Compile Tools'''== -=====For EDK II project developers on Windows with source BaseTools:===== -* Create a workspace directory -* Change to the workspace directory -* Clone the EDK II project repository (See [[Windows-systems#download| Download]] section above) -** Example: git clone https://github.com/tianocore/edk2 -* Install Python37 or late version (https://www.python.org/) to run python tool from source -* Compile BaseTools C source tools -Example: -* Inside Git Bash -<pre> - $ git clone https://github.com/tianocore/edk2 -</pre> -=====Compile BaseTools===== -Example: -*Open Command prompt and CD C:\edk2: -<pre> +__NOTOC__ + + Note: New build instructions are available. It is recommended to start with the new instructions if learning how to + build edk2 for the first time. This page is retained for reference. + +New instructions: [[Build-Instructions.md|Build Instructions]] + +This page provides step-by-step instructions or setting up a [http://www.tianocore.org/edk2/ EDK II] build environment on Windows systems. + +<u>''Table of Contents''</u> +* [[Windows-systems#github-help|GitHub Help]] +* [[Windows-systems#how-to-setup-the-edk-ii-tree| How to Setup the EDK II Tree]] +* [[Windows-systems#download| Download]] Checkout EDK II source tree from Github +* [[Windows-systems#compile-tools |Compile Tools]] Build EDK II BaseTools for Windows +* [[Windows-systems#build | BUILD]] EDK II + +==GitHub Help== + +GitHub (https://help.github.com/index.html) provides step-by-step instructions for user registration and basic features supported by GitHub. + +=== Git GUI Interface for Windows OS === +* Git for Windows OS is available at: (http://git-scm.com/download/win) +* TortoiseGit for windows OS is available at (https://tortoisegit.org/download/) + +=='''GitHub EDK II Project Repositories'''== + +* The EDK II project repository is available at https://github.com/tianocore/edk2. + +Content that is not released under an accepted open source license can be found at https://github.com/tianocore/edk2-non-osi.<br /> + <br /> +Note: the steps below will pull the latest code from edk2 master. To work from a stable release, please refer to the Microsoft Windows build steps for [[UDK2017]]: https://github.com/tianocore/tianocore.github.io/wiki/UDK2017-How-to-Build#how-to-build-windows-system + +===Internet proxies=== + +If your network utilizes a firewall with a web proxy, then you may need to configure your proxy information for various command line applications to work. You may need to consult with your network administrator to find out the computer name and port to use for proxy setup. The following commands are common '''Git Bash''' examples of how you would configure your proxy by setting an environment variable: + +<pre> + $ git config --global https.proxy <proxyname>.domain.com:<port> + $ git config --global http.proxy <proxyname>.domain.com:<port> +</pre> + + +=='''How to Setup the EDK II Tree'''== +'''Note:''' Some of the following examples use the Multiple Workspace feature to configure the EDK II BaseTools. More information on the Multiple Workspace feature can be found at the following location. <BR> +* [[Multiple_Workspace]] + +=='''Download'''== +Download/Checkout the EDK II source tree from Github +=== Download Using a Web browser === + +# Download EDK II Project +## Open https://github.com/tianocore/edk2 in web browser +## Click on the ''Clone or Download'' button (Right Green) +## Click on Download ZIP +## Unzip to C:/ +## Rename directory “edk2-master” to “edk2” + +Continue to [[Windows-systems#compile-tools |Compile Tools]] + +=== Using '''Git for Windows''' Application === +==== ''Git GUI''==== +# Clone the EDK II project repository +## Open Git GUI +## Use ''Clone Exiting Repository'' with Source location https://github.com/tianocore/edk2.git +## Select a Target directory C:/edk2 +## Check Recursively clone submodules too +## click Clone button + +Continue to [[Windows-systems#compile-tools |Compile Tools]] section + +==== ''Git CMD'' ==== +If you use the command line version, then you can easily checkout the edk2 to the C:\edk2 directory with the following git command: +Main repository: https://github.com/tianocore/edk2 +<pre> + $git clone https://github.com/tianocore/edk2 +</pre> + +Continue to [[Windows-systems#compile-tools |Compile Tools]] and then [[Windows-systems#build | BUILD]] sections + +=='''Compile Tools'''== +=====For EDK II project developers on Windows with source BaseTools:===== +* Create a workspace directory +* Change to the workspace directory +* Clone the EDK II project repository (See [[Windows-systems#download| Download]] section above) +** Example: git clone https://github.com/tianocore/edk2 +* Install Python37 or late version (https://www.python.org/) to run python tool from source +* Compile BaseTools C source tools +Example: +* Inside Git Bash +<pre> + $ git clone https://github.com/tianocore/edk2 +</pre> +=====Compile BaseTools===== +Example: +*Open Command prompt and CD C:\edk2: +<pre> C:\edk2> set PYTHON_HOME=C:\Python37 - C:\edk2> edksetup.bat Rebuild -</pre> - - -=='''Build'''== -* Set up the [[Nasm-Setup| Nasm]] open source assembly compiler -* Set up the [[Asl Setup| ASL Compiler]] -* [[Windows-systems#compile-tools |Compile Tools]] above -* Open a Windows CMD prompt: -* Change to the edk2 directory -* Run the edksetup.bat script - - C:\Users\MySid> CD \edk2 - C:\edk2> edksetup - -===Build MdeModulePkg=== - - -====Modify Conf files==== - -You will need to edit the Conf\target.txt file. First, change the ACTIVE_PLATFORM to the MdeModulePkg: - -<pre> -C:\edk2> notepad Conf\target.txt -</pre> - -ACTIVE_PLATFORM should look like this in Conf\target.txt: - -<pre> -ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc -</pre> - -Modify TOOL_CHAIN_TAG in target.txt for the toolchain installed on your system. There are many options, so review the tools_def.txt to find the appropriate toolchain for your system. Search for 'Supported Tool Chains' in tools_def.txt to see the valid options for TOOL_CHAIN_TAG. -<pre> -TOOL_CHAIN_TAG = VS2015x86 -</pre> - - - -See also: [[Windows-systems-ToolChain-Matrix]] for how to change the Tool Chain Tag. - -Also, consider if you want to build a different processor architecture by changing the TARGET_ARCH value in target.txt. Please consider that certain toolchains only support building certain processor architectures. - -====Build Hello World! (and the rest of MdeModulePkg)==== - -Now you should be able to simply run the build command to compile the MdeModulePkg. - -<pre> -C:\edk2> build -</pre> - -As a tangible result of the build, you should have the HelloWorld UEFI application. If you have a UEFI system available to you which matches the processor architecture that you built, then this application should be able to run successfully under the shell. - -<pre> -C:\edk2> dir /s Build\MdeModule\DEBUG_...\IA32\HelloWorld.efi -</pre> - -===Build [[OVMF]] (OPTIONAL)=== - -Once your build environment is set up you might be interested in building the [[OVMF]] platform which is included in the main edk2 source tree. Since [[OVMF]] builds a full system firmware image this may be of interest to UEFI system firmware developers. - -=See Also= -* [[Getting-Started-Writing-Simple-Application]] - + C:\edk2> edksetup.bat Rebuild +</pre> + + +=='''Build'''== +* Set up the [[Nasm-Setup| Nasm]] open source assembly compiler +* Set up the [[Asl Setup| ASL Compiler]] +* [[Windows-systems#compile-tools |Compile Tools]] above +* Open a Windows CMD prompt: +* Change to the edk2 directory +* Run the edksetup.bat script + + C:\Users\MySid> CD \edk2 + C:\edk2> edksetup + +===Build MdeModulePkg=== + + +====Modify Conf files==== + +You will need to edit the Conf\target.txt file. First, change the ACTIVE_PLATFORM to the MdeModulePkg: + +<pre> +C:\edk2> notepad Conf\target.txt +</pre> + +ACTIVE_PLATFORM should look like this in Conf\target.txt: + +<pre> +ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc +</pre> + +Modify TOOL_CHAIN_TAG in target.txt for the toolchain installed on your system. There are many options, so review the tools_def.txt to find the appropriate toolchain for your system. Search for 'Supported Tool Chains' in tools_def.txt to see the valid options for TOOL_CHAIN_TAG. +<pre> +TOOL_CHAIN_TAG = VS2015x86 +</pre> + + + +See also: [[Windows-systems-ToolChain-Matrix]] for how to change the Tool Chain Tag. + +Also, consider if you want to build a different processor architecture by changing the TARGET_ARCH value in target.txt. Please consider that certain toolchains only support building certain processor architectures. + +====Build Hello World! (and the rest of MdeModulePkg)==== + +Now you should be able to simply run the build command to compile the MdeModulePkg. + +<pre> +C:\edk2> build +</pre> + +As a tangible result of the build, you should have the HelloWorld UEFI application. If you have a UEFI system available to you which matches the processor architecture that you built, then this application should be able to run successfully under the shell. + +<pre> +C:\edk2> dir /s Build\MdeModule\DEBUG_...\IA32\HelloWorld.efi +</pre> + +===Build [[OVMF]] (OPTIONAL)=== + +Once your build environment is set up you might be interested in building the [[OVMF]] platform which is included in the main edk2 source tree. Since [[OVMF]] builds a full system firmware image this may be of interest to UEFI system firmware developers. + +=See Also= +* [[Getting-Started-Writing-Simple-Application]] + <!-- [[Category:EDKII]] --> \ No newline at end of file -- 2.28.0.windows.1 |
|
4881 - 4900 of 101797 |