diff --git a/.gdbinit b/.gdbinit new file mode 100644 index 0000000..5806f5e --- /dev/null +++ b/.gdbinit @@ -0,0 +1,13 @@ +set logging off +set breakpoint pending on +set print demangle on +set print asm-demangle on +set print object on +set print static-members on +set disassembly-flavor intel +set backtrace limit 20 +set language c++ + +b granary_curiosity +b granary_unreachable + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ff2d33e --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +bin/* +.project +.cproject +.settings/* +test/*_01 +test/*_02 +test/*_03 + + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0d089ce --- /dev/null +++ b/Makefile @@ -0,0 +1,185 @@ +# Copyright 2015 Peter Goodman, all rights reserved. + +.PHONY: all clean + +GRANARY_CC ?= clang-3.6 +GRANARY_CXX ?= clang++-3.6 + +# Where is Granary's source code located? +GRANARY_SRC_DIR ?= $(shell pwd) +GRANARY_LIB_DIR := $(GRANARY_SRC_DIR)/third_party +GRANARY_GEN_DIR := $(GRANARY_SRC_DIR)/gen + +# What OS are we compiling for? +GRANARY_OS ?= decree + +# Where will Granary run? Specify `kernel` for kernel space, and `user` for +# user space. +GRANARY_WHERE ?= user + +# What type of build should be perform? +GRANARY_TARGET ?= debug + +# Useful for distinguishing different kinds of builds. +GRANARY_TRIPLE := $(GRANARY_TARGET)_$(GRANARY_OS)_$(GRANARY_WHERE) + +# Where should we emit object files and the executable? +GRANARY_BIN_DIR ?= $(GRANARY_SRC_DIR)/bin/$(GRANARY_TRIPLE) + +# Should we assume that Granary will be executed with Valgrind? +GRANARY_WITH_VALGRIND ?= 0 + +# Compiler warnings that are explicitly disabled. +GRANARY_DISABLED_WARNINGS := -Wno-gnu-anonymous-struct +GRANARY_DISABLED_WARNINGS += -Wno-gnu-conditional-omitted-operand +GRANARY_DISABLED_WARNINGS += -Wno-long-long +GRANARY_DISABLED_WARNINGS += -Wno-gnu-statement-expression +GRANARY_DISABLED_WARNINGS += -Wno-nested-anon-types +GRANARY_DISABLED_WARNINGS += -Wno-extended-offsetof +GRANARY_DISABLED_WARNINGS += -Wno-c++98-compat-pedantic -Wno-c++98-compat +GRANARY_DISABLED_WARNINGS += -Wno-padded +GRANARY_DISABLED_WARNINGS += -Wno-unused-macros +GRANARY_DISABLED_WARNINGS += -Wno-missing-variable-declarations +GRANARY_DISABLED_WARNINGS += -Wno-missing-prototypes +GRANARY_DISABLED_WARNINGS += -Wno-packed +GRANARY_DISABLED_WARNINGS += -Wno-global-constructors +GRANARY_DISABLED_WARNINGS += -Wno-exit-time-destructors +GRANARY_DISABLED_WARNINGS += -Wno-disabled-macro-expansion +GRANARY_DISABLED_WARNINGS += -Wno-date-time +GRANARY_DISABLED_WARNINGS += -Wno-reserved-id-macro + +# Arch-specific flags. +GRANARY_ARCH_FLAGS := -m64 -mtune=generic -fPIC -ffreestanding +GRANARY_ARCH_FLAGS += -ftls-model=initial-exec -mno-red-zone +GRANARY_ARCH_FLAGS += -fno-common -fno-builtin +GRANARY_ARCH_FLAGS += -fno-stack-protector -minline-all-stringops + +# Flags that are common to both C and C++ compilers. +GRANARY_COMMON_FLAGS := +GRANARY_COMMON_FLAGS += -I$(GRANARY_SRC_DIR) +GRANARY_COMMON_FLAGS += -Wall -Werror -Wpedantic +GRANARY_COMMON_FLAGS += $(GRANARY_DISABLED_WARNINGS) +GRANARY_COMMON_FLAGS += -DGRANARY_WHERE_$(GRANARY_WHERE) +GRANARY_COMMON_FLAGS += -DGRANARY_OS_$(GRANARY_OS) +GRANARY_COMMON_FLAGS += -DGRANARY_TARGET_$(GRANARY_TARGET) +GRANARY_COMMON_FLAGS += -DGOOGLE_PROTOBUF_NO_RTTI + +GRANARY_SANITIZER ?= + +# Optimization and debug information level. +ifeq (debug,$(GRANARY_TARGET)) + GRANARY_COMMON_FLAGS += -O0 -g3 -fno-inline + ifneq (,$(GRANARY_SANITIZER)) + GRANARY_COMMON_FLAGS += -fsanitize=$(GRANARY_SANITIZER) + endif +else + GRANARY_COMMON_FLAGS += -Oz -g3 +endif + +# Flags to pass to the various compilers. +# +# Note: We don't pass in Musl as a system include so that libc++ can pick up +# on specific system-defined macros in libc that Musl doesn't provide. +# +# Note: We need to pass in libc++ as we're not guaranteed that the +# distribution version of libc++ exactly matches the Granary version, and +# even minor differences can result in missing symbols. +GRANARY_CC_FLAGS := -std=c11 $(GRANARY_COMMON_FLAGS) $(GRANARY_ARCH_FLAGS) +GRANARY_CXX_FLAGS := -std=c++11 #-stdlib=libstdc++ +GRANARY_CXX_FLAGS += $(GRANARY_COMMON_FLAGS) $(GRANARY_ARCH_FLAGS) +GRANARY_CXX_FLAGS += -fno-exceptions -fno-asynchronous-unwind-tables -fno-rtti +GRANARY_CXX_FLAGS += -isystem $(GRANARY_LIB_DIR)/gflags/include + +# C, C++, and assembly files in Granary. +GRANARY_SRC_FILES := $(shell find $(GRANARY_SRC_DIR)/granary/ -name '*.cc' -or -name '*.c' -or -name '*.S' -type f) +GRANARY_SRC_FILES += $(shell find $(GRANARY_SRC_DIR)/third_party/ -name '*.cc' -or -name '*.c' -or -name '*.S' -type f) + +DUMP_SRC_FILES = $(GRANARY_SRC_DIR)/coverage.cc +DUMP_SRC_FILES += $(GRANARY_SRC_DIR)/granary/code/index.cc +DUMP_SRC_FILES += $(GRANARY_SRC_DIR)/granary/base/breakpoint.cc +DUMP_SRC_FILES += $(GRANARY_SRC_DIR)/granary/base/interrupt.cc +DUMP_SRC_FILES += $(GRANARY_LIB_DIR)/xxhash/xxhash.c +DUMP_OBJECT_FILES := $(addsuffix .o, $(subst $(GRANARY_SRC_DIR),$(GRANARY_BIN_DIR),$(DUMP_SRC_FILES))) + +PLAY_SRC_FILES = $(GRANARY_SRC_DIR)/play.cc $(GRANARY_SRC_DIR)/play.cc $(GRANARY_SRC_FILES) +PLAY_OBJECT_FILES := $(addsuffix .o, $(subst $(GRANARY_SRC_DIR),$(GRANARY_BIN_DIR),$(PLAY_SRC_FILES))) + +SNAPSHOT_SRC_FILES := $(GRANARY_SRC_DIR)/snapshot.cc +SNAPSHOT_SRC_FILES += $(GRANARY_SRC_DIR)/granary/os/snapshot.cc +SNAPSHOT_SRC_FILES += $(GRANARY_SRC_DIR)/granary/os/decree_user/snapshot.cc +SNAPSHOT_SRC_FILES += $(GRANARY_SRC_DIR)/granary/base/breakpoint.cc +SNAPSHOT_SRC_FILES += $(GRANARY_SRC_DIR)/granary/base/interrupt.cc +SNAPSHOT_OBJ_FILES := $(addsuffix .o, $(subst $(GRANARY_SRC_DIR),$(GRANARY_BIN_DIR),$(SNAPSHOT_SRC_FILES))) + +# Compile C++ files to object files. +$(GRANARY_BIN_DIR)/%.pb.cc.o :: $(GRANARY_SRC_DIR)/%.pb.cc + @echo "Building CXX object $@" + @mkdir -p $(@D) + @$(GRANARY_CXX) -Weverything -Wno-sign-conversion -Wno-shorten-64-to-32 $(GRANARY_CXX_FLAGS) -c $< -o $@ + +# Compile C++ files to object files. +$(GRANARY_BIN_DIR)/%.cc.o :: $(GRANARY_SRC_DIR)/%.cc + @echo "Building CXX object $@" + @mkdir -p $(@D) + @$(GRANARY_CXX) -Weverything $(GRANARY_CXX_FLAGS) -c $< -o $@ + +# Compile C files to object files. +$(GRANARY_BIN_DIR)/%.c.o :: $(GRANARY_SRC_DIR)/%.c + @echo "Building C object $@" + @mkdir -p $(@D) + @$(GRANARY_CC) $(GRANARY_CC_FLAGS) -c $< -o $@ + +# Compile assembly files to object files. +$(GRANARY_BIN_DIR)/%.S.o :: $(GRANARY_SRC_DIR)/%.S + @echo "Building ASM object $@" + @mkdir -p $(@D) + @$(GRANARY_CC) $(GRANARY_COMMON_FLAGS) $(GRANARY_ARCH_FLAGS) -c $< -o $@ + +# Build the Granary executable. +$(GRANARY_BIN_DIR)/grrplay: $(PLAY_OBJECT_FILES) + @echo "Linking $@" + @$(GRANARY_CXX) \ + $(GRANARY_CXX_FLAGS) \ + -o $@ \ + $^ \ + $(GRANARY_LIB_DIR)/xed-intel64/lib/libxed.a \ + $(GRANARY_LIB_DIR)/gflags/lib/libgflags_nothreads.a \ + -lpthread \ + -static-libstdc++ \ + -static-libgcc + +# Build the Granary executable. +$(GRANARY_BIN_DIR)/grrshot: $(SNAPSHOT_OBJ_FILES) + @echo "Linking $@" + @$(GRANARY_CXX) \ + $(GRANARY_CXX_FLAGS) \ + -o $@ \ + $^ \ + $(GRANARY_LIB_DIR)/gflags/lib/libgflags_nothreads.a \ + -lpthread \ + -static-libstdc++ \ + -static-libgcc + +# Build the program to print out a code cache. +$(GRANARY_BIN_DIR)/grrcov: $(DUMP_OBJECT_FILES) + @echo "Linking $@" + @$(GRANARY_CXX) \ + $(GRANARY_CXX_FLAGS) \ + -o $@ \ + $^ \ + $(GRANARY_LIB_DIR)/gflags/lib/libgflags_nothreads.a \ + -lpthread \ + -static-libstdc++ \ + -static-libgcc + +clean: + @rm -rf $(GRANARY_BIN_DIR) + +all: $(GRANARY_BIN_DIR)/grrplay $(GRANARY_BIN_DIR)/grrshot $(GRANARY_BIN_DIR)/grrcov + @echo "Done." + +install: + mkdir -p $(GRANARY_PREFIX_DIR)/bin + cp $(GRANARY_BIN_DIR)/grrplay $(GRANARY_PREFIX_DIR)/bin + cp $(GRANARY_BIN_DIR)/grrshot $(GRANARY_PREFIX_DIR)/bin + cp $(GRANARY_BIN_DIR)/grrcov $(GRANARY_PREFIX_DIR)/bin diff --git a/README.md b/README.md new file mode 100644 index 0000000..9e29581 --- /dev/null +++ b/README.md @@ -0,0 +1,63 @@ +Granary3 +======== + +This is a simple implementation of an x86 to amd64 binary translator. The +purpose of this binary translator is for use with DECREE binaries. + +Key features: + * Support for self-modifying code (e.g. JIT compilers). + * Simple block tracing infrastructure (superblock formation). + * Code cache persistence (avoids translation overheads across separate runs). + * Multi-processing support (allows multiple communicating, 32-bit processes + to be emulated within a single 64-bit address space). + +### Dependencies + +``` +sudo apt-get install -y git build-essential +sudo apt-get install -y clang-3.5 clang++-3.5 llvm-3.5-dev libc++1 libc++-dev +sudo apt-get install -y libgflags-dev libprotobuf-dev libprotoc-dev +``` + +### Compiling +#### Debug Build +```sh +make clean all +``` +#### Release Build +```sh +make all GRANARY_TARGET=release +``` + +### Running + +There are two steps to running Granary: snapshotting, and record/replaying. Snapshotting creates an initial image of the binary after `execve`. Record/replaying takes an input testcase (formatted as a protocol buffer) and attempts to replay that testcase. The replay can be recorded or mutated as well. + +#### Snapshotting +If you are on an AMD64 port of the CGC kernel, then you can do this: +```sh +./bin/debug_linux_user/grrshot --num_exe=1 --exe_dir=/path --exe_prefix=CADET_000 --snapshit_dir=/tmp/snapshot +``` +This will create a snapshot of `/path/CADET_00001` and store the snapshot into the `/tmp/snapshot` directory. + +If you are on a non-CGC AMD64 port, then make sure to do the following first: +```sh +cgc2elf /path/CADET_00001 +``` + +#### Replaying +```sh +./bin/debug_linux_user/grrplay --num_exe=1 --snapshot_dir=/tmp/snapshot --persist_dir=/tmp/persist --input=/path/to/testcase +``` + +#### Replay + Recording +```sh +./bin/debug_linux_user/grrplay --num_exe=1 --snapshot_dir=/tmp/snapshot --persist_dir=/tmp/persist --input=/path/to/testcase --output_dir=/tmp/out +``` + +#### Replay + Recording + Mutating +```sh +./bin/debug_linux_user/grrplay --num_exe=1 --snapshot_dir=/tmp/snapshot --persist_dir=/tmp/persist --input=/path/to/testcase --output_dir=/tmp/out --input_mutator=inf_radamsa_spliced +``` + +There are many mutators. Some of the mutators are deterministic, and therefore run for a period of time that is proportional to the number of `receive` system calls in the input testcase. Other mutators are non-deterministic and can run forever. These mutators are prefixed with `inf_`. diff --git a/coverage.cc b/coverage.cc new file mode 100644 index 0000000..3eac5b5 --- /dev/null +++ b/coverage.cc @@ -0,0 +1,31 @@ +/* Copyright 2015 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#include + +#include + +#include "granary/code/index.h" + +DEFINE_bool(persist, true, "Should the code cache be persisted?"); + +DEFINE_string(persist_dir, "", "Directory path to where runtime state should " + "be persisted. This should be unique for a " + "given set of binaries."); + +extern "C" int main(int argc, char **argv, char **) { + using namespace granary; + gflags::SetUsageMessage(std::string(argv[0]) + " [options]"); + gflags::ParseCommandLineFlags(&argc, &argv, false); + + if (FLAGS_persist_dir.empty()) { + std::cerr << "Must provide a unique path to a directory where the " + << "runtime state can be persisted." << std::endl; + return EXIT_FAILURE; + } + + index::Init(); + + index::Dump(); + + return EXIT_SUCCESS; +} diff --git a/granary/arch/base.h b/granary/arch/base.h new file mode 100644 index 0000000..b637e47 --- /dev/null +++ b/granary/arch/base.h @@ -0,0 +1,16 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + + +#ifndef GRANARY_ARCH_BASE_H_ +#define GRANARY_ARCH_BASE_H_ + +namespace granary { +namespace arch { + +void Init(void); +void Exit(void); + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_BASE_H_ diff --git a/granary/arch/cpu.h b/granary/arch/cpu.h new file mode 100644 index 0000000..3566cf3 --- /dev/null +++ b/granary/arch/cpu.h @@ -0,0 +1,16 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_CPU_H_ +#define GRANARY_ARCH_CPU_H_ + +namespace granary { +namespace arch { + +void Relax(void); + +void SerializePipeline(void); + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_CPU_H_ diff --git a/granary/arch/fault.h b/granary/arch/fault.h new file mode 100644 index 0000000..e2608a2 --- /dev/null +++ b/granary/arch/fault.h @@ -0,0 +1,25 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef GRANARY_ARCH_FAULT_H_ +#define GRANARY_ARCH_FAULT_H_ + +#include "granary/base/base.h" + +namespace granary { +namespace os { +class Process32; +} // namespace os +namespace arch { + +void DecomposeFaultAddr( + const os::Process32 *process, + Addr32 *base, + Addr32 *index, + Addr32 *scale, + Addr32 *disp, + Addr32 fault_addr); + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_FAULT_H_ diff --git a/granary/arch/instruction.h b/granary/arch/instruction.h new file mode 100644 index 0000000..5df3068 --- /dev/null +++ b/granary/arch/instruction.h @@ -0,0 +1,32 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_INSTRUCTION_H_ +#define GRANARY_ARCH_INSTRUCTION_H_ + +#include "granary/arch/x86/instruction.h" + +#include + +namespace granary { +namespace arch { + +// Used to allocate instructions in the REVERSE of the order that they +// will be encoded. +class InstructionStack : public std::forward_list { + public: + inline Instruction *Add(void) { + Instruction instr; + memset(&instr, 0, sizeof instr); + auto item = this->emplace_after(this->before_begin()); + return &*item; + } + + inline void Reset(void) { + this->clear(); + } +}; + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_INSTRUCTION_H_ diff --git a/granary/arch/instrument.h b/granary/arch/instrument.h new file mode 100644 index 0000000..4c6814d --- /dev/null +++ b/granary/arch/instrument.h @@ -0,0 +1,24 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_INSTRUMENT_H_ +#define GRANARY_ARCH_INSTRUMENT_H_ + +#include "granary/base/base.h" + +#include "granary/code/instrument.h" + +namespace granary { +namespace arch { + +// Initialize instrumentation routines for use within basic blocks. +void InitInstrumentationFunctions(CachePC instrument_section); + +// Returns the location in the code cache of where this instrumentation +// function is. +CachePC GetInstrumentationFunction(code::InstrumentationPoint loc); + +} // namespace arch +} // namespace granary + + +#endif // GRANARY_ARCH_INSTRUMENT_H_ diff --git a/granary/arch/isa.h b/granary/arch/isa.h new file mode 100644 index 0000000..8941a2e --- /dev/null +++ b/granary/arch/isa.h @@ -0,0 +1,30 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_ISA_H_ +#define GRANARY_ARCH_ISA_H_ + +namespace granary { +namespace arch { + +enum class ISA { + x86, + amd64 +}; + +template +constexpr unsigned AddressWidth(void); + +template <> +constexpr unsigned AddressWidth(void) { + return 32U; +} + +template <> +constexpr unsigned AddressWidth(void) { + return 64U; +} + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_ISA_H_ diff --git a/granary/arch/patch.h b/granary/arch/patch.h new file mode 100644 index 0000000..e07a031 --- /dev/null +++ b/granary/arch/patch.h @@ -0,0 +1,17 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/base/base.h" + +#ifndef GRANARY_ARCH_PATCH_H_ +#define GRANARY_ARCH_PATCH_H_ + +namespace granary { +namespace arch { + +void InitPatcher(void); +void ExitPatcher(void); + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_PATCH_H_ diff --git a/granary/arch/x86/abi.h b/granary/arch/x86/abi.h new file mode 100644 index 0000000..0758092 --- /dev/null +++ b/granary/arch/x86/abi.h @@ -0,0 +1,40 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_X86_ABI_H_ +#define GRANARY_ARCH_X86_ABI_H_ + +// The 64-bit base address of a 32-bit process. +#define GRANARY_ABI_MEM64 XED_REG_R8 + +// The 32-bit address of the virtual thread's stack. This is a byte offset +// within `GRANARY_ABI_MEM`. +#define GRANARY_ABI_SP16 XED_REG_R9W +#define GRANARY_ABI_SP32 XED_REG_R9D +#define GRANARY_ABI_SP64 XED_REG_R9 + +// 32-bit program counter of the current / next block. +#define GRANARY_ABI_PC8 XED_REG_R10B +#define GRANARY_ABI_PC16 XED_REG_R10W +#define GRANARY_ABI_PC32 XED_REG_R10D +#define GRANARY_ABI_PC64 XED_REG_R10 + +// A scratch register for storing a computed value. +#define GRANARY_ABI_VAL8 XED_REG_R11B +#define GRANARY_ABI_VAL16 XED_REG_R11W +#define GRANARY_ABI_VAL32 XED_REG_R11D +#define GRANARY_ABI_VAL64 XED_REG_R11 + +// Scratch register for storing a computed address. +#define GRANARY_ABI_ADDR8 XED_REG_R12B +#define GRANARY_ABI_ADDR16 XED_REG_R12W +#define GRANARY_ABI_ADDR32 XED_REG_R12D +#define GRANARY_ABI_ADDR64 XED_REG_R12 + +// The process structure for saving/restoring things. +#define GRANARY_ABI_PROCESS64 XED_REG_R15 + +// The `index::Value` of the cached block being executed. +#define GRANARY_ABI_BLOCK64 XED_REG_R14 +#define GRANARY_ABI_BLOCK32 XED_REG_R14D + +#endif // GRANARY_ARCH_X86_ABI_H_ diff --git a/granary/arch/x86/base.cc b/granary/arch/x86/base.cc new file mode 100644 index 0000000..59df96c --- /dev/null +++ b/granary/arch/x86/base.cc @@ -0,0 +1,20 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/base.h" +#include "granary/arch/patch.h" +#include "granary/arch/x86/xed-intel64.h" + +namespace granary { +namespace arch { + +void Init(void) { + xed_tables_init(); + InitPatcher(); +} + +void Exit(void) { + ExitPatcher(); +} + +} // namespace arch +} // namespace granary diff --git a/granary/arch/x86/block.cc b/granary/arch/x86/block.cc new file mode 100644 index 0000000..d37e224 --- /dev/null +++ b/granary/arch/x86/block.cc @@ -0,0 +1,1144 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/cpu.h" + +#include "granary/arch/x86/abi.h" +#include "granary/arch/x86/patch.h" + +#include "granary/code/block.h" +#include "granary/code/cache.h" + +#include "granary/arch/instrument.h" + +#ifndef GRANARY_REPORT_ENCODER_ERRORS +# define GRANARY_REPORT_ENCODER_ERRORS 0 +#endif + +#ifndef GRANARY_REPORT_EMULATE_RRORS +# define GRANARY_REPORT_EMULATE_RRORS 0 +#endif + +namespace granary { +namespace arch { +extern const xed_state_t kXEDState64; +} // namespace arch +namespace { + +struct PatchPoint { + AppPC32 app_pc32; + const arch::Instruction *cache_instr; +}; + +static PatchPoint gBranchTaken = {0, nullptr}; +static PatchPoint gBranchNotTaken = {0, nullptr}; + +// Inject an instrumentation function call. +static void Instrument(Block *block, code::InstrumentationPoint ipoint) { + auto func_pc = arch::GetInstrumentationFunction(ipoint); + auto instr = block->cache_instructions.Add(); + instr->has_pc_rel_op = true; + instr->reencode_pc_rel_op = true; + xed_inst1(instr, arch::kXEDState64, XED_ICLASS_CALL_NEAR, + arch::kAddrWidthBits_amd64, xed_relbr(0, 32)); + instr->operands[1].u.imm0 = reinterpret_cast(func_pc); +} + +// Inject an instrumentation function call. +static void InstrumentPC(Block *block, Addr32 pc) { + const auto &ids = code::GetInstrumentationIds(pc); + if (ids.empty()) { + return; + } + + // This will end up applying the IDs in reverse order (desirable) because of + // the way we build up basic blocks. + for (auto id : ids) { + Instrument(block, code::InstrumentationPoint::kInstrumentPC); + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, 32, + xed_reg(GRANARY_ABI_VAL32), xed_imm0(id, 32)); + } +} + +// Re-encodes a relative branch operand. +void UpdateRelBranch(arch::Instruction *instr, CachePC encode_pc) { + if (!instr->reencode_pc_rel_op) return; + auto target = reinterpret_cast(instr->operands[1].u.imm0); + auto next_pc = encode_pc + instr->encoded_length; + GRANARY_ASSERT(32 == instr->operands[0].width); + instr->operands[0] = xed_relbr(target - next_pc, 32); + instr->is_valid = false; +} + +// Resizes `reg` to the desired `size` in bits. +static xed_reg_enum_t ResizeReg(xed_reg_enum_t reg, size_t size) { + enum { + kReg64To32 = XED_REG_RAX - XED_REG_EAX, + kReg64To16 = XED_REG_RAX - XED_REG_AX, + kReg64To8 = XED_REG_AL - XED_REG_RAX + }; + auto reg64 = xed_get_largest_enclosing_register(reg); + switch (size) { + case 8: return static_cast(reg64 + kReg64To8); + case 16: return static_cast(reg64 - kReg64To16); + case 32: return static_cast(reg64 - kReg64To32); + case 64: return reg64; + default: + GRANARY_ASSERT(false && "Non-GPR cannot be resized."); + return XED_REG_INVALID; + } +} + +// Loads the address computed by `op` into the `ADDR32` reg. +static void LoadEffectiveAddress(Block *block, + const xed_encoder_operand_t &op) { + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_LEA, arch::kAddrWidthBits_x86, + xed_reg(GRANARY_ABI_ADDR32), op); + instr->operands[1].u.mem.seg = XED_REG_INVALID; +} + +// Returns `true` if this instruction has an effective address. +static bool IsEffectiveAddress(const arch::Instruction *app_instr) { + return XED_ICLASS_BNDCL == app_instr->iclass || + XED_ICLASS_BNDCN == app_instr->iclass || + XED_ICLASS_BNDCU == app_instr->iclass || + XED_ICLASS_BNDMK == app_instr->iclass || + //XED_ICLASS_CLFLUSH == app_instr->iclass || + //XED_ICLASS_CLFLUSHOPT == app_instr->iclass || + XED_ICLASS_LEA == app_instr->iclass; + //(XED_ICLASS_PREFETCHNTA <= app_instr->iclass && + // XED_ICLASS_PREFETCH_RESERVED >= app_instr->iclass); +} + +// Relativizes a PC-relative memory operand. +static void Relativize(const arch::Instruction *app_instr, + xed_encoder_operand_t &op) { + auto logical_eip = app_instr->EndPC(); + auto curr_disp = static_cast(op.u.mem.disp.displacement); + auto pc_disp = static_cast(logical_eip); + auto new_disp = pc_disp + curr_disp; + GRANARY_ASSERT(0 <= new_disp); + // TODO(pag): We assume user space addresses that are positive. + + op.u.mem.disp.displacement = static_cast(new_disp); + op.u.mem.disp.displacement_width = 32; + + if (IsEffectiveAddress(app_instr)) { + op.u.mem.base = XED_REG_INVALID; + op.u.mem.seg = XED_REG_INVALID; + } else { + op.u.mem.base = GRANARY_ABI_MEM64; + } +} + +// Virtualize a register to be the ABI version of the stack pointer. +static void VirtualizeStack(xed_reg_enum_t ®) { + if (XED_REG_ESP == reg) reg = GRANARY_ABI_SP32; + if (XED_REG_SP == reg) reg = GRANARY_ABI_SP16; +} + +// Rebase a memory operand to use the memory base register. +static void Rebase(Block *block, xed_encoder_operand_t &op) { + GRANARY_ASSERT(32 >= op.u.mem.disp.displacement_width); + auto ea = op; + Instrument(block, code::InstrumentationPoint::kInstrumentMemoryAddress); + VirtualizeStack(ea.u.mem.base); + LoadEffectiveAddress(block, ea); + + op.u.mem.base = GRANARY_ABI_MEM64; + op.u.mem.index = GRANARY_ABI_ADDR64; + op.u.mem.scale = 1; + op.u.mem.disp.displacement = 0; + op.u.mem.disp.displacement_width = 0; +} + +// Loads the register `src` into the register `reg`. +static void LoadReg(Block *block, xed_reg_enum_t dst, xed_reg_enum_t src); + +// Resize a legacy register to be 8 bits wide. +static xed_reg_enum_t ResizeLegacy8(xed_reg_enum_t reg) { + switch (reg) { + case XED_REG_RAX: return XED_REG_AL; + case XED_REG_RCX: return XED_REG_CL; + case XED_REG_RDX: return XED_REG_DL; + case XED_REG_RBX: return XED_REG_BL; + default: + GRANARY_ASSERT(false && "Could not resize non-legacy register."); + return XED_REG_INVALID; + } +} + +// Returns whether or not an operand is a destination operand. This is quite a +// hack :-P +static bool OpIsWrite(const xed_encoder_operand_t &op) { + return XED_ENCODER_OPERAND_TYPE_INVALID != (&op)[1].type; +} + +// Virtualize a memory operand. +static void VirtualizeMem(Block *block, const arch::Instruction *app_instr, + xed_encoder_operand_t &op) { + if (!IsEffectiveAddress(app_instr)) { + Rebase(block, op); + + // We don't want to rebase effective addresses with `GRANARY_ABI_MEM64`. + } else { + VirtualizeStack(op.u.mem.base); + } +} + +// Virtualize a memory operand that is being used in an instruction where a +// legacy reg (AH, CH, BH, DH) in the instruction. +static void VirtualizeLegacyMem(Block *block, + const arch::Instruction *app_instr, + xed_encoder_operand_t &op, + xed_reg_enum_t stolen_reg64) { + // We have something like `MOV MEM, legacy_reg8`; convert into: + // + // LEA stolen_reg64, MEM + // MOV [stolen_reg64], legacy_reg8 + if (OpIsWrite(op)) { + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_LEA, + arch::kAddrWidthBits_amd64, xed_reg(stolen_reg64), op); + instr->operands[1].u.mem.seg = XED_REG_INVALID; + VirtualizeMem(block, app_instr, instr->operands[1]); + + op.u.mem.base = stolen_reg64; + op.u.mem.index = XED_REG_INVALID; + op.u.mem.scale = 0; + op.u.mem.seg = XED_REG_INVALID; + op.u.mem.disp.displacement = 0; + op.u.mem.disp.displacement_width = 0; + + // We have something like `MOV legacy_reg8, MEM`; convert into: + // + // MOV val8, MEM + // MOV stolen_reg64, val64 + // MOV legacy_reg8, stolen_reg8 + } else { + LoadReg(block, stolen_reg64, GRANARY_ABI_VAL64); + + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, 8, + xed_reg(GRANARY_ABI_VAL8), op); + VirtualizeMem(block, app_instr, instr->operands[1]); + + op.type = XED_ENCODER_OPERAND_TYPE_REG; + op.u.reg = ResizeLegacy8(stolen_reg64); + } +} + +// Virtualizes a register or memory operand. +// +// Note: `op` is from the *copy* of `app_instr` that has already been enstackd. +static void Virtualize(Block *block, const arch::Instruction *app_instr, + xed_encoder_operand_t &op, + xed_reg_enum_t stolen_reg=XED_REG_INVALID) { + switch (op.type) { + case XED_ENCODER_OPERAND_TYPE_REG: + VirtualizeStack(op.u.reg); + break; + + case XED_ENCODER_OPERAND_TYPE_MEM: + if (app_instr) { + if (XED_REG_EIP == op.u.mem.base) { + GRANARY_ASSERT(!op.u.mem.index); + Relativize(app_instr, op); + } else if (app_instr->uses_legacy_registers) { + VirtualizeLegacyMem(block, app_instr, op, stolen_reg); + } else { + VirtualizeMem(block, app_instr, op); + } + } else { + Rebase(block, op); + } + break; + default: + break; + } +} + +// Loads a value into the value register. +static void LoadValue(Block *block, const arch::Instruction *app_instr, + const xed_encoder_operand_t &op) { + auto instr = block->cache_instructions.Add(); + auto size = op.width; + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, size, + xed_reg(ResizeReg(GRANARY_ABI_VAL64, size)), op); + Virtualize(block, app_instr, instr->operands[1]); +} + +// Sign- or zero-extends the ABI value register. +static void ExtendValue(Block *block, xed_iclass_enum_t extender, + size_t from_size, size_t to_size) { + if (from_size < to_size) { + auto val_reg = ResizeReg(GRANARY_ABI_VAL64, from_size); + auto val_reg_ext = ResizeReg(GRANARY_ABI_VAL64, to_size); + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, extender, to_size, + xed_reg(val_reg_ext), xed_reg(val_reg)); + } +} + +// Loads a sign-extended value into the ABI value register. +static void LoadSignedValue(Block *block, const arch::Instruction *app_instr, + const xed_encoder_operand_t &op) { + ExtendValue(block, XED_ICLASS_MOVSX, op.width, + app_instr->effective_operand_width); + LoadValue(block, app_instr, op); +} + +// Ends a block. +static void EndBlock(Block *block) { + auto instr = block->cache_instructions.Add(); + xed_inst0(instr, arch::kXEDState64, XED_ICLASS_RET_NEAR, + arch::kAddrWidthBits_amd64); +} + +// Save a register's value. +static void SaveReg(Block *block, xed_reg_enum_t reg) { + auto instr = block->cache_instructions.Add(); + xed_inst1(instr, arch::kXEDState64, XED_ICLASS_PUSH, + arch::kAddrWidthBits_amd64, + xed_reg(xed_get_largest_enclosing_register(reg))); +} + +// Restore a register's value. +static void RestoreReg(Block *block, xed_reg_enum_t reg) { + auto instr = block->cache_instructions.Add(); + xed_inst1(instr, arch::kXEDState64, XED_ICLASS_POP, + arch::kAddrWidthBits_amd64, + xed_reg(xed_get_largest_enclosing_register(reg))); +} + +// Loads the immediate constant into the register `reg`. +static void LoadImm(Block *block, xed_reg_enum_t reg, uint64_t imm) { + auto instr = block->cache_instructions.Add(); + auto imm_size = xed_get_register_width_bits64(reg); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, imm_size, + xed_reg(reg), xed_imm0(imm, imm_size)); +} + +// Loads the register `src` into the register `dst`. +static void LoadReg(Block *block, xed_reg_enum_t dst, xed_reg_enum_t src) { + auto instr = block->cache_instructions.Add(); + auto reg_size = xed_get_register_width_bits64(dst); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, reg_size, + xed_reg(dst), xed_reg(src)); +} + +// Loads the register `src` with the value of the virtual memory location +// addressed by `src_addr`. +static void LoadMem(Block *block, xed_reg_enum_t dst, + xed_reg_enum_t src_addr) { + auto instr = block->cache_instructions.Add(); + auto size = xed_get_register_width_bits64(dst); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, arch::kAddrWidthBits_x86, + xed_reg(dst), + xed_mem_bisd(GRANARY_ABI_MEM64, src_addr, 1, xed_disp(0, 8), size)); +} + +// Loads the value of the operand `op` into the register `dst`. This will +// auto-virtualize the operand. This assumes that the size of `reg` is +// compatible with the size of `op`. +static void LoadOp(Block *block, const arch::Instruction *app_instr, + xed_reg_enum_t dst, const xed_encoder_operand_t &op) { + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, arch::kAddrWidthBits_x86, + xed_reg(dst), op); + Virtualize(block, app_instr, instr->operands[1]); +} + +// Write an immediate integer to the virtual memory location `addr`. +static void StoreImm32(Block *block, xed_reg_enum_t addr, uint32_t val) { + auto instr = block->cache_instructions.Add(); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, arch::kAddrWidthBits_x86, + xed_mem_bisd(GRANARY_ABI_MEM64, addr, 1, + xed_disp(0, 8), arch::kAddrWidthBits_x86), + xed_imm0(val, 32)); +} + +// Write an immediate integer to the virtual memory location `addr`. +static void StoreReg(Block *block, xed_reg_enum_t addr, xed_reg_enum_t reg) { + auto instr = block->cache_instructions.Add(); + auto width = xed_get_register_width_bits64(reg); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, width, + xed_mem_bisd(GRANARY_ABI_MEM64, addr, 1, + xed_disp(0, 8), width), + xed_reg(reg)); +} + +// Write the value of a register into an operand. This will virtualize the +// operand if necessary. +static void StoreOp(Block *block, const arch::Instruction *app_instr, + const xed_encoder_operand_t &op, xed_reg_enum_t reg) { + auto instr = block->cache_instructions.Add(); + auto width = xed_get_register_width_bits64(reg); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_MOV, width, + op, xed_reg(reg)); + Virtualize(block, app_instr, instr->operands[0]); +} + +// Performs a small constant shift of the virtual stack pointer. +static void BumpSP(Block *block, intptr_t shift_) { + GRANARY_ASSERT(0 != shift_); + auto instr = block->cache_instructions.Add(); + auto shift = static_cast(shift_); + xed_inst2(instr, arch::kXEDState64, XED_ICLASS_LEA, arch::kAddrWidthBits_x86, + xed_reg(GRANARY_ABI_SP32), + xed_mem_bd(GRANARY_ABI_SP32, xed_disp(shift, 8), + arch::kAddrWidthBits_x86)); +} + +// Pushes a register onto the stack. +static void PushReg(Block *block, xed_reg_enum_t reg) { + auto reg_size = xed_get_register_width_bits64(reg); + StoreReg(block, GRANARY_ABI_SP64, reg); + BumpSP(block, -(reg_size / 8)); +} + +// Pops the value on the stack into the register `reg`. +static void PopReg(Block *block, xed_reg_enum_t reg) { + auto reg_size = xed_get_register_width_bits64(reg); + auto stack_op = xed_mem_b(XED_REG_ESP, reg_size); + BumpSP(block, reg_size / 8); + LoadOp(block, nullptr, reg, stack_op); +} + +// Record the EIP of block containing the last multi-way branch. +static void RecordLastMultiWayBranch(Block *block) { + static_assert(52 == offsetof(os::Process32, last_branch_pc), + "Bad structure packing of `os::Process32`."); + auto update_last_cfi = block->cache_instructions.Add(); + xed_inst2(update_last_cfi, arch::kXEDState64, XED_ICLASS_MOV, + arch::kAddrWidthBits_x86, + xed_mem_bd(GRANARY_ABI_PROCESS64, + // offsetof(os::Process32, last_branch_pc) + xed_disp(52, 8), + arch::kAddrWidthBits_x86), + xed_reg(GRANARY_ABI_BLOCK32)); +} + +static const arch::Instruction *PatchableJump(Block *block) { + auto patch = block->cache_instructions.Add(); + xed_inst1(patch, arch::kXEDState64, XED_ICLASS_JMP, + arch::kAddrWidthBits_amd64, xed_relbr(0, 32)); + return patch; +} + +// Virtualizes an application branch instruction. +static void VirtualizeBranch(Block *block, const arch::Instruction *cfi) { + gBranchTaken.app_pc32 = cfi->TargetPC(); + gBranchTaken.cache_instr = PatchableJump(block); + + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + LoadImm(block, GRANARY_ABI_PC32, cfi->TargetPC()); + + // If the condition isn't taken then we fall-through and return to here. + EndBlock(block); + + gBranchNotTaken.app_pc32 = cfi->EndPC(); + gBranchNotTaken.cache_instr = PatchableJump(block); + + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + + auto cond = block->cache_instructions.Add(); + memcpy(cond, cfi, sizeof *cond); + cond->mode = arch::kXEDState64; + cond->effective_operand_width = arch::kAddrWidthBits_amd64; + cond->effective_address_width = arch::kAddrWidthBits_amd64; + cond->operands[0].width = 8; + + // Jump around the: + // 1) Patchable `jmp`. Initially points at (2). + // 2) `call` into the instrumentation point. + // 3) `mov` of the block `eip` into the Process' last branch pc. + // 4) `ret` back to the dispatcher. + cond->operands[0].u.brdisp = 15; + + LoadImm(block, GRANARY_ABI_PC32, cfi->EndPC()); +} + +// Emulates a direct jump. +static bool EmulateDirectJump(Block *block, const arch::Instruction *cfi) { + LoadImm(block, GRANARY_ABI_PC32, cfi->TargetPC()); + return true; +} + +// Emulates an indirect jump. +static bool EmulateIndirectJump(Block *block, const arch::Instruction *cfi) { + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + LoadOp(block, cfi, GRANARY_ABI_PC32, cfi->operands[0]); + return true; +} + +// Emulates a direct function call. +static bool EmulateDirectFunctionCall(Block *block, + const arch::Instruction *cfi) { + LoadImm(block, GRANARY_ABI_PC32, cfi->TargetPC()); + StoreImm32(block, GRANARY_ABI_SP64, cfi->EndPC()); + BumpSP(block, -arch::kAddrWidthBytes_x86); + return true; +} + +// Emulates an indirect function call. +static bool EmulateIndirectFunctionCall(Block *block, + const arch::Instruction *cfi) { + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + StoreImm32(block, GRANARY_ABI_SP64, cfi->EndPC()); + BumpSP(block, -arch::kAddrWidthBytes_x86); + LoadOp(block, cfi, GRANARY_ABI_PC32, cfi->operands[0]); + return true; +} + +// Emulates a function return. +static bool EmulateFunctionReturn(Block *block, const arch::Instruction *cfi) { + const auto &imm = cfi->operands[0]; + if (XED_ENCODER_OPERAND_TYPE_IMM0 == imm.type) { + BumpSP(block, imm.u.imm0); + } + BumpSP(block, arch::kAddrWidthBytes_x86); + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + LoadMem(block, GRANARY_ABI_PC32, GRANARY_ABI_SP64); + return true; +} + +// Emulates a JCXZ, which is not valid in amd64. +static void EmulateJcxz(Block *block, const arch::Instruction *cfi) { + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + LoadReg(block, XED_REG_ECX, GRANARY_ABI_VAL32); + LoadImm(block, GRANARY_ABI_PC32, cfi->TargetPC()); + + // If the condition isn't taken then we fall-through and return to here. + EndBlock(block); + LoadReg(block, XED_REG_ECX, GRANARY_ABI_VAL32); + + RecordLastMultiWayBranch(block); + Instrument(block, code::InstrumentationPoint::kInstrumentMultiWayBranch); + + // Jump around the `MOV ECX, VAL32; RET` and the instrumentation. + auto cond = block->cache_instructions.Add(); + memcpy(cond, cfi, sizeof *cond); + cond->mode = arch::kXEDState64; + cond->iclass = XED_ICLASS_JECXZ; + cond->operands[0].u.brdisp = 3 + 1 + 9; + + LoadImm(block, GRANARY_ABI_PC32, cfi->EndPC()); + + ExtendValue(block, XED_ICLASS_MOVZX, XED_REG_ECX, XED_REG_CX); + LoadReg(block, GRANARY_ABI_VAL32, XED_REG_ECX); +} + +// Emulates a conditional jump/branch instruction. +static bool EmulateBranch(Block *block, const arch::Instruction *cfi) { + if (XED_ICLASS_JCXZ == cfi->iclass) { + EmulateJcxz(block, cfi); + } else { + VirtualizeBranch(block, cfi); + } + return true; +} + +// Add a padding byte before a block. +static void AddPadding(Block *block) { + auto instr = block->cache_instructions.Add(); + xed_inst0(instr, arch::kXEDState64, XED_ICLASS_INT3, 0); +} + +// Convert an instruction into a UD2. +static void ConvertToError(Block *block, arch::Instruction *instr) { + xed_inst0(instr, arch::kXEDState64, XED_ICLASS_UD2, 0); + instr->is_valid = false; + block->has_error = true; +} + +// Adds an error instruction (UD2). +static void AddError(Block *block) { + ConvertToError(block, block->cache_instructions.Add()); +} + +// Emulates an interrupt call. This actually sets up the fall-through PC as a +// tagged PC (where the high bit is 1 to mark it as a syscall) so that the +// syscall can be handled by the interpreter and so that we don't need to +// inject anything into the code cache that can't be relocated. +static bool EmulateInterruptCall(Block *block, const arch::Instruction *cfi) { + if (XED_ICLASS_INT == cfi->iclass && 0x80 == cfi->operands[0].u.imm0) { + block->has_syscall = true; + LoadImm(block, GRANARY_ABI_PC32, cfi->EndPC()); + } else { + // E.g. INT1, INT3, INTO, INT imm8 != 0x80. + AddError(block); + } + return true; +} + +// Forward declaration. +static bool EmulatePopFlags(Block *block, xed_reg_enum_t rflags); + +// Emulates an interrupt return. +static bool EmulateInterruptReturn(Block *block, const arch::Instruction *cfi) { + GRANARY_ASSERT(XED_ICLASS_IRETD == cfi->iclass); + EmulatePopFlags(block, GRANARY_ABI_VAL32); + PopReg(block, XED_REG_CS); + PopReg(block, GRANARY_ABI_PC32); + GRANARY_UNUSED(cfi); + return true; +} + +// Returns the set of available legacy registers as dead registers in the +// returned GPRSet. +static xed_reg_enum_t UnusedLegacyReg(const arch::Instruction *app_instr) { + arch::GPRSet used_regs; + used_regs.bits = app_instr->gprs_read.bits | app_instr->gprs_written.bits; + if (!used_regs.gax) return XED_REG_RAX; + if (!used_regs.gcx) return XED_REG_RCX; + if (!used_regs.gbx) return XED_REG_RBX; + if (!used_regs.gdx) return XED_REG_RDX; + GRANARY_ASSERT(false && "No live legacy regs available."); + return XED_REG_INVALID; +} + +// Add an instruction `instr` to `block`s encode stack. +static void Virtualize(Block *block, const arch::Instruction *app_instr) { + xed_reg_enum_t stolen_reg = XED_REG_INVALID; + if (app_instr->uses_legacy_registers && + (app_instr->reads_mem || app_instr->writes_mem)) { + stolen_reg = UnusedLegacyReg(app_instr); + GRANARY_ASSERT(XED_REG_INVALID != stolen_reg); + RestoreReg(block, stolen_reg); + } + + auto instr = block->cache_instructions.Add(); + memcpy(instr, app_instr, sizeof *instr); + instr->mode = arch::kXEDState64; + instr->effective_address_width = arch::kAddrWidthBits_amd64; + + for (auto &op : instr->operands) { + if (XED_ENCODER_OPERAND_TYPE_INVALID == op.type) break; + Virtualize(block, app_instr, op, stolen_reg); + } + + if (XED_REG_INVALID != stolen_reg) { + SaveReg(block, stolen_reg); + } +} + +// Emulate a `SYSCALL` or `SYSENTER` instruction. +static bool EmulateSyscall(Block *block, const arch::Instruction *app_instr) { + GRANARY_UNUSED(block); + GRANARY_UNUSED(app_instr); +#if GRANARY_REPORT_EMULATE_RRORS + GRANARY_ASSERT(false && "Unexpected SYSCALL or SYSENTER instruction."); +#else + AddError(block); +#endif + return true; +} + +// Emulate a `SYSRET` or `SYSEXIT` instruction. +static bool EmulateSysret(Block *block, const arch::Instruction *app_instr) { + GRANARY_UNUSED(block); + GRANARY_UNUSED(app_instr); +#if GRANARY_REPORT_EMULATE_RRORS + GRANARY_ASSERT(false && "Unexpected SYSRET or SYSEXIT instruction."); +#else + AddError(block); +#endif + return true; +} + +// Adds a control-flow instruction into the stack. Returns `true` if `cfi` +// is actually a control-flow instruction and has been fully emulated. +static bool EmulateCFI(Block *block, arch::Instruction *cfi) { + if (cfi->IsDirectJump()) { + return EmulateDirectJump(block, cfi); + } else if (cfi->IsIndirectJump()) { + return EmulateIndirectJump(block, cfi); + } else if (cfi->IsDirectFunctionCall()) { + return EmulateDirectFunctionCall(block, cfi); + } else if (cfi->IsIndirectFunctionCall()) { + return EmulateIndirectFunctionCall(block, cfi); + } else if (cfi->IsFunctionReturn()) { + return EmulateFunctionReturn(block, cfi); + } else if (cfi->IsBranch()) { + return EmulateBranch(block, cfi); + } else if (cfi->IsSystemCall()) { + block->has_syscall = true; + return EmulateSyscall(block, cfi); + } else if (cfi->IsSystemReturn()) { + return EmulateSysret(block, cfi); + } else if (cfi->IsInterruptCall()) { + return EmulateInterruptCall(block, cfi); + } else if (cfi->IsInterruptReturn()) { + return EmulateInterruptReturn(block, cfi); + + // Not a control-flow instruction, need to add a fall-through. + } else { + LoadImm(block, GRANARY_ABI_PC32, cfi->EndPC()); + return false; + } +} + +// Emulates a push instruction. +static bool EmulatePush(Block *block, const arch::Instruction *app_instr) { + const auto op_size = app_instr->effective_operand_width; + const auto &op = app_instr->operands[0]; + PushReg(block, ResizeReg(GRANARY_ABI_VAL64, op_size)); + LoadSignedValue(block, app_instr, op); + return true; +} + +// Emulates a pop instruction. +static bool EmulatePop(Block *block, const arch::Instruction *app_instr) { + auto op_size = app_instr->effective_operand_width; + auto stack_op = xed_mem_b(XED_REG_ESP, op_size); + auto val = ResizeReg(GRANARY_ABI_VAL64, op_size); + StoreOp(block, app_instr, app_instr->operands[0], val); + BumpSP(block, op_size / 8); + LoadSignedValue(block, app_instr, stack_op); + return true; +} + +// Emulates a push-all instruction. +static bool EmulatePusha(Block *block) { + PushReg(block, XED_REG_DI); + PushReg(block, XED_REG_SI); + PushReg(block, XED_REG_BP); + PushReg(block, GRANARY_ABI_VAL16); + PushReg(block, XED_REG_BX); + PushReg(block, XED_REG_DX); + PushReg(block, XED_REG_CX); + PushReg(block, XED_REG_AX); + LoadReg(block, GRANARY_ABI_VAL16, GRANARY_ABI_SP16); + return true; +} + +// Emulates a pop-all instruction. +static bool EmulatePopa(Block *block) { + PopReg(block, XED_REG_AX); + PopReg(block, XED_REG_CX); + PopReg(block, XED_REG_DX); + PopReg(block, XED_REG_BX); + BumpSP(block, 2); + PopReg(block, XED_REG_BP); + PopReg(block, XED_REG_SI); + PopReg(block, XED_REG_DI); + return true; +} + +// Emulates a push-all doublewords instruction. +static bool EmulatePushad(Block *block) { + PushReg(block, XED_REG_EDI); + PushReg(block, XED_REG_ESI); + PushReg(block, XED_REG_EBP); + PushReg(block, GRANARY_ABI_VAL32); + PushReg(block, XED_REG_EBX); + PushReg(block, XED_REG_EDX); + PushReg(block, XED_REG_ECX); + PushReg(block, XED_REG_EAX); + LoadReg(block, GRANARY_ABI_VAL32, GRANARY_ABI_SP32); + return true; +} + +// Emulates a pop-all doublewords instruction. +static bool EmulatePopad(Block *block) { + PopReg(block, XED_REG_EAX); + PopReg(block, XED_REG_ECX); + PopReg(block, XED_REG_EDX); + PopReg(block, XED_REG_EBX); + BumpSP(block, 4); + PopReg(block, XED_REG_EBP); + PopReg(block, XED_REG_ESI); + PopReg(block, XED_REG_EDI); + return true; +} + +// Emulates pushing some portion of the `RFLAGS` onto the stack. +static bool EmulatePushFlags(Block *block, xed_reg_enum_t rflags) { + PushReg(block, rflags); + auto pop_val = block->cache_instructions.Add(); + xed_inst1(pop_val, arch::kXEDState64, XED_ICLASS_POP, + arch::kAddrWidthBits_amd64, xed_reg(GRANARY_ABI_VAL64)); + + auto pushfq = block->cache_instructions.Add(); + xed_inst0(pushfq, arch::kXEDState64, XED_ICLASS_PUSHFQ, + arch::kAddrWidthBits_amd64); + return true; +} + +// Emulates popping the top of the stack into some portion of `RFLAGS`. +static bool EmulatePopFlags(Block *block, xed_reg_enum_t rflags) { + auto rflags_width = xed_get_register_width_bits64(rflags); + + auto popfq = block->cache_instructions.Add(); + xed_inst0(popfq, arch::kXEDState64, XED_ICLASS_POPFQ, + arch::kAddrWidthBits_amd64); + + auto overwrite = block->cache_instructions.Add(); + xed_inst2(overwrite, arch::kXEDState64, XED_ICLASS_MOV, rflags_width, + xed_mem_b(XED_REG_RSP, rflags_width), xed_reg(rflags)); + + // Mask off `ID`, which permits the identification of whether or not + // the `CPUID` instruction is supported. + if (32 == rflags_width) { + auto mask = block->cache_instructions.Add(); + auto rflags_reg64 = xed_get_largest_enclosing_register(rflags); + xed_inst2(mask, arch::kXEDState64, XED_ICLASS_AND, 64, + xed_reg(rflags_reg64), xed_imm0(0xffdfffff, 32)); + } + + auto pushfq = block->cache_instructions.Add(); + xed_inst0(pushfq, arch::kXEDState64, XED_ICLASS_PUSHFQ, + arch::kAddrWidthBits_amd64); + + PopReg(block, rflags); + return true; +} + +// Emulates the `ENTER` instruction. +static bool EmulateEnter(Block *block, const arch::Instruction *app_instr) { + GRANARY_UNUSED(block); + GRANARY_UNUSED(app_instr); +#if GRANARY_REPORT_EMULATE_RRORS + GRANARY_ASSERT("TODO: ENTER" && false); // TODO(pag): Implement me. +#else + AddError(block); +#endif + return true; +} + +// Emulates the `LEAVE` instruction. +static bool EmulateLeave(Block *block, const arch::Instruction *app_instr) { + auto reg_width = app_instr->effective_operand_width; + auto base_pointer = ResizeReg(XED_REG_EBP, reg_width); + auto stack_pointer = ResizeReg(GRANARY_ABI_SP64, reg_width); + PopReg(block, base_pointer); + LoadReg(block, stack_pointer, base_pointer); + return true; +} + +// Emulates the `BOUND` instruction. +static bool EmulateBound(Block *block, const arch::Instruction *app_instr) { + GRANARY_UNUSED(block); + GRANARY_UNUSED(app_instr); +#if GRANARY_REPORT_EMULATE_RRORS + GRANARY_ASSERT("TODO: BOUND" && false); // TODO(pag): Implement me. +#else + AddError(block); +#endif + return true; +} + +// Emulates the `XLAT` instruction. +static bool EmulateXLAT(Block *block, const arch::Instruction *app_instr) { + GRANARY_UNUSED(block); + GRANARY_UNUSED(app_instr); +#if GRANARY_REPORT_EMULATE_RRORS + GRANARY_ASSERT("TODO: XLAT" && false); // TODO(pag): Implement me. +#else + AddError(block); +#endif + return true; +} + +// Emulates a string operation. It does this by widening RDI/RSI with the base +// of memory address, then it shorts them back again by adding the two's +// complement of the +static bool EmulateStringOp(Block *block, const arch::Instruction *app_instr) { + // Shorten RDI and RSI back to 32-bit addresses by adding the complemented + // 32-bit memory base and 1 (i.e. two's complement negation of the 32-bit + // memory base). + auto shorten_rdi = block->cache_instructions.Add(); + xed_inst2(shorten_rdi, arch::kXEDState64, XED_ICLASS_LEA, + arch::kAddrWidthBits_amd64, xed_reg(XED_REG_RDI), + xed_mem_gbisd(XED_REG_INVALID, XED_REG_RDI, GRANARY_ABI_VAL64, 1, + xed_disp(1, 8), arch::kAddrWidthBits_amd64)); + + auto shorten_rsi = block->cache_instructions.Add(); + xed_inst2(shorten_rsi, arch::kXEDState64, XED_ICLASS_LEA, + arch::kAddrWidthBits_amd64, xed_reg(XED_REG_RSI), + xed_mem_gbisd(XED_REG_INVALID, XED_REG_RSI, GRANARY_ABI_VAL64, 1, + xed_disp(1, 8), arch::kAddrWidthBits_amd64)); + + // Complement the base of memory. + auto not_ = block->cache_instructions.Add(); + xed_inst1(not_, arch::kXEDState64, XED_ICLASS_NOT, + arch::kAddrWidthBits_amd64, xed_reg(GRANARY_ABI_VAL64)); + LoadReg(block, GRANARY_ABI_VAL64, GRANARY_ABI_MEM64); + + // Virtualize the original instruction, which will make the effective address + // width of the implicit EDI/ESI operands into RDI/RSI. + Virtualize(block, app_instr); + + // Widen RSI and RDI by the base of the address space. + auto widen_rsi = block->cache_instructions.Add(); + xed_inst2(widen_rsi, arch::kXEDState64, XED_ICLASS_LEA, + arch::kAddrWidthBits_amd64, xed_reg(XED_REG_RSI), + xed_mem_gbisd(XED_REG_INVALID, XED_REG_RSI, GRANARY_ABI_MEM64, 1, + xed_disp(0, 0), arch::kAddrWidthBits_amd64)); + + auto widen_rdi = block->cache_instructions.Add(); + xed_inst2(widen_rdi, arch::kXEDState64, XED_ICLASS_LEA, + arch::kAddrWidthBits_amd64, xed_reg(XED_REG_RDI), + xed_mem_gbisd(XED_REG_INVALID, XED_REG_RDI, GRANARY_ABI_MEM64, 1, + xed_disp(0, 0), arch::kAddrWidthBits_amd64)); + return true; +} + +// Add an emulated version of `app_instr` to `block`. +static bool Emulate(Block *block, const arch::Instruction *app_instr) { + switch (app_instr->iclass) { + case XED_ICLASS_PUSH: + return EmulatePush(block, app_instr); + case XED_ICLASS_POP: + return EmulatePop(block, app_instr); + case XED_ICLASS_PUSHA: + return EmulatePusha(block); + case XED_ICLASS_POPA: + return EmulatePopa(block); + case XED_ICLASS_PUSHAD: + return EmulatePushad(block); + case XED_ICLASS_POPAD: + return EmulatePopad(block); + case XED_ICLASS_PUSHF: + return EmulatePushFlags(block, GRANARY_ABI_VAL16); + case XED_ICLASS_POPF: + return EmulatePopFlags(block, GRANARY_ABI_VAL16); + case XED_ICLASS_PUSHFD: + return EmulatePushFlags(block, GRANARY_ABI_VAL32); + case XED_ICLASS_POPFD: + return EmulatePopFlags(block, GRANARY_ABI_VAL32); + case XED_ICLASS_ENTER: + return EmulateEnter(block, app_instr); + case XED_ICLASS_LEAVE: + return EmulateLeave(block, app_instr); + case XED_ICLASS_BOUND: + return EmulateBound(block, app_instr); + case XED_ICLASS_UD2: + case XED_ICLASS_RDTSC: + case XED_ICLASS_RDTSCP: + case XED_ICLASS_RDPMC: + case XED_ICLASS_RDRAND: + AddError(block); + return true; + case XED_ICLASS_XLAT: + return EmulateXLAT(block, app_instr); + case XED_ICLASS_NOP: + case XED_ICLASS_NOP2: + case XED_ICLASS_NOP3: + case XED_ICLASS_NOP4: + case XED_ICLASS_NOP5: + case XED_ICLASS_NOP6: + case XED_ICLASS_NOP7: + case XED_ICLASS_NOP8: + case XED_ICLASS_NOP9: + return true; // Don't encode NOPs. + case XED_ICLASS_INSB: case XED_ICLASS_REP_INSB: + case XED_ICLASS_INSD: case XED_ICLASS_REP_INSD: + case XED_ICLASS_INSW: case XED_ICLASS_REP_INSW: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_OUTSB: case XED_ICLASS_REP_OUTSB: + case XED_ICLASS_OUTSD: case XED_ICLASS_REP_OUTSD: + case XED_ICLASS_OUTSW: case XED_ICLASS_REP_OUTSW: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_MOVSB: case XED_ICLASS_REP_MOVSB: + case XED_ICLASS_MOVSW: case XED_ICLASS_REP_MOVSW: + case XED_ICLASS_MOVSD: case XED_ICLASS_REP_MOVSD: + case XED_ICLASS_MOVSQ: case XED_ICLASS_REP_MOVSQ: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_STOSB: case XED_ICLASS_REP_STOSB: + case XED_ICLASS_STOSD: case XED_ICLASS_REP_STOSW: + case XED_ICLASS_STOSW: case XED_ICLASS_REP_STOSD: + case XED_ICLASS_STOSQ: case XED_ICLASS_REP_STOSQ: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_SCASB: + case XED_ICLASS_SCASD: + case XED_ICLASS_SCASW: + case XED_ICLASS_SCASQ: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_CMPSB: + case XED_ICLASS_CMPSD: + case XED_ICLASS_CMPSW: + case XED_ICLASS_CMPSQ: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_LODSB: case XED_ICLASS_REP_LODSB: + case XED_ICLASS_LODSD: case XED_ICLASS_REP_LODSW: + case XED_ICLASS_LODSW: case XED_ICLASS_REP_LODSD: + case XED_ICLASS_LODSQ: case XED_ICLASS_REP_LODSQ: + return EmulateStringOp(block, app_instr); + case XED_ICLASS_REPE_CMPSB: + case XED_ICLASS_REPE_CMPSD: + case XED_ICLASS_REPE_CMPSQ: + case XED_ICLASS_REPE_CMPSW: + case XED_ICLASS_REPE_SCASB: + case XED_ICLASS_REPE_SCASD: + case XED_ICLASS_REPE_SCASQ: + case XED_ICLASS_REPE_SCASW: + case XED_ICLASS_REPNE_CMPSB: + case XED_ICLASS_REPNE_CMPSD: + case XED_ICLASS_REPNE_CMPSQ: + case XED_ICLASS_REPNE_CMPSW: + case XED_ICLASS_REPNE_SCASB: + case XED_ICLASS_REPNE_SCASD: + case XED_ICLASS_REPNE_SCASQ: + case XED_ICLASS_REPNE_SCASW: + return EmulateStringOp(block, app_instr); + default: + return false; + } +} + +// Adds a patch point. Patchable jumps are `JMP rel32`, where the JMP opcode +// is 1 byte, and the rel32 is an int32_t. +static void AddPatchPoint(AppPC32 target_pc, CachePC encoded_pc) { + arch::AddPatchPoint(&(encoded_pc[1]), target_pc); +} + +// Report an encoding failure; we need to print out as much info as we can +// get. +static void ReportEncoderFailure(Block *block, arch::Instruction &instr) { +#if GRANARY_REPORT_ENCODER_ERRORS + char buff[4096] = {'\0'}; + auto offs = sprintf(buff, "Could not encode block [%x, %x):\n Block Data:", + block->StartPC(), block->EndPC()); + + offs += sprintf(buff + offs, "\n Instruction Data:"); + auto instr_bytes = reinterpret_cast( + reinterpret_cast(&instr)); + for (auto i = 0UL; i < sizeof instr; ++i) { + offs += sprintf(buff + offs, " %02x", + static_cast(instr_bytes[i])); + } + + granary_unreachable(buff, nullptr, false /* Don't die */); +#else + GRANARY_UNUSED(block); +#endif + + // Convert into a `UD2`. + xed_inst0(&instr, arch::kXEDState64, XED_ICLASS_UD2, 0); + instr.is_valid = false; + ConvertToError(block, &instr); +} + +} // namespace + +// Encodes the the block and returns a pointer to the location in the code +// cache at which the block was encoded. +// +// Note: This function is NOT thread safe. `EncodedSize` and `Encode` should +// be performed in a transaction. +void Block::Encode(index::Value &val) { + EndBlock(this); + + if (GRANARY_UNLIKELY(!num_app_instructions)) { + val.ends_with_error = true; + LoadImm(this, GRANARY_ABI_PC32, StartPC()); + + } else { + auto ainstr = &(app_instructions[num_app_instructions - 1].instruction); + auto first_ainstr = &(app_instructions[0].instruction); + + // Try to emulate the last instruction as a control-flow instruction. + if (EmulateCFI(this, ainstr)) { + val.has_one_successor = ainstr->IsDirectJump() || + ainstr->IsDirectFunctionCall(); + val.ends_with_syscall = has_syscall; + + // Record the PC of the jump instruction. Useful if we have a fault when + // loading the target (e.g. an indirect jump where the target is stored + // in memory). + LoadImm(this, GRANARY_ABI_PC32, ainstr->StartPC()); + + --ainstr; + + // It wasn't a control-flow instruction, so we emulated it with a direct + // jump, and so it only has one successor. + } else { + val.has_one_successor = !ainstr->IsSerializing(); + val.ends_with_error = ainstr->IsUndefined(); + } + + // For each remaining app instruction (in reverse order), try to emulate, + // andif not, virtualize each instruction. + for (; ainstr >= first_ainstr; --ainstr) { + GRANARY_ASSERT(XED_ICLASS_INVALID != ainstr->iclass); + + if (!Emulate(this, ainstr)) { + Virtualize(this, ainstr); + } + + // Instrument the instruction at this program counter. + InstrumentPC(this, ainstr->StartPC()); + + // Load the exact PC32 of each instruction just before emulating the + // instruction. This gives us precise PCs when reporting crashes. + LoadImm(this, GRANARY_ABI_PC32, ainstr->StartPC()); + } + //Instrument(this, code::kInstrumentBlockEntry); + } + + // Find the beginning of the block. We might push + auto start_cache_pc = cache::Allocate(0); + auto actual_start_cache_pc = start_cache_pc; + if (auto extra = reinterpret_cast(start_cache_pc) % 8) { + actual_start_cache_pc += (8 - extra); + } + + val.cache_offset = cache::PCToOffset(actual_start_cache_pc); + + // On entry to the block, add the block's identifying info in. + LoadImm(this, GRANARY_ABI_BLOCK64, val.value); + + // Add padding before the entry of the block to align blocks to 8-byte + // boundaries. + for (; start_cache_pc < actual_start_cache_pc; ++start_cache_pc) { + AddPadding(this); + } + + // Encode the instructions. + for (auto &einstr : cache_instructions) { + auto instr_size = einstr.NumEncodedBytes(); + if (!instr_size) { + ReportEncoderFailure(this, einstr); + has_error = true; + instr_size = einstr.NumEncodedBytes(); + } + + if (instr_size) { + auto encode_pc = cache::Allocate(instr_size); + UpdateRelBranch(&einstr, encode_pc); + einstr.Encode(encode_pc); + + if (&einstr == gBranchTaken.cache_instr) { + GRANARY_ASSERT(5 == instr_size); + AddPatchPoint(gBranchTaken.app_pc32, encode_pc); + memset(&gBranchTaken, 0, sizeof gBranchTaken); + } + + if (&einstr == gBranchNotTaken.cache_instr) { + GRANARY_ASSERT(5 == instr_size); + AddPatchPoint(gBranchNotTaken.app_pc32, encode_pc); + memset(&gBranchNotTaken, 0, sizeof gBranchNotTaken); + } + } + } + + // Report back up the chain (to the indexer) that this block has an error + // in it (somewhere). This will prevent us from even executing it. + if (has_error) { + val.ends_with_error = true; + } + + arch::SerializePipeline(); +} + +} // namespace granary + diff --git a/granary/arch/x86/branch_tracer.S b/granary/arch/x86/branch_tracer.S new file mode 100644 index 0000000..29ae78c --- /dev/null +++ b/granary/arch/x86/branch_tracer.S @@ -0,0 +1,66 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + + .file "granary/arch/x86/branch_tracer.S" + .intel_syntax noprefix + .text + + .extern TraceBranchImpl + + // r15 os::Process32 * Process32 object. + // r14 index::Value Meta-data about this block. + // r13 Scratch. + // r12 Scratch. + // r11 Scratch. + // r10 Addr32 EIP. + // r9 Addr32 ESP. + // r8 Addr64 64-bit base of 32-bit address space. + // + .align 16 + .globl TraceBranch + .type TraceBranch, @function +TraceBranch: + .cfi_startproc + + pushfq + push rax + push rbx + push rcx + push rdx + push rbp + push rsi + push rdi + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + + mov edi, dword ptr [r15 + 52] + mov esi, r14d + mov edx, r10d + call TraceBranchImpl + + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + pop rdi + pop rsi + pop rbp + pop rdx + pop rcx + pop rbx + pop rax + popfq + + ret + .cfi_endproc + .size TraceBranch, .-TraceBranch + ud2 diff --git a/granary/arch/x86/cache.S b/granary/arch/x86/cache.S new file mode 100644 index 0000000..ebcc537 --- /dev/null +++ b/granary/arch/x86/cache.S @@ -0,0 +1,149 @@ + + .file "granary/arch/x86/cache.S" + .intel_syntax noprefix + + .data +granary_stack_pointer: + .quad 0 + + .extern gInlineCache + + + // Used to return from the code cache with a bad block. + .align 16 + .globl granary_bad_block + .type granary_bad_block, @function +granary_bad_block: + .cfi_startproc + xor r14, r14 + not r14 + mov r11, [RIP + granary_stack_pointer] + sub r11, 8 + mov rsp, r11 + ret + .cfi_endproc + .size _ZN7granary5cache4CallEPNS_2os9Process32EPh, .-_ZN7granary5cache4CallEPNS_2os9Process32EPh + ud2 + + // CachePC cache::Call(os::Process32 *process, CachePC block); + .align 16 + .globl _ZN7granary5cache4CallEPNS_2os9Process32EPh; + .type _ZN7granary5cache4CallEPNS_2os9Process32EPh, @function +_ZN7granary5cache4CallEPNS_2os9Process32EPh: + .cfi_startproc + + /* Save the Linux ABI callee-saved regs */ + push rbx ; .cfi_def_cfa_offset 16 + push rbp ; .cfi_def_cfa_offset 24 + push r12 ; .cfi_def_cfa_offset 32 + push r13 ; .cfi_def_cfa_offset 40 + push r14 ; .cfi_def_cfa_offset 48 + push r15 ; .cfi_def_cfa_offset 56 + + /* Process address */ + mov r15, rdi + + /* Block address */ + mov r14, rsi + + /* Base of memory */ + mov r8, [r15] + + /* Restore EFLAGS */ + push word ptr [r15 + 44] ; .cfi_def_cfa_offset 60 + popf ; .cfi_def_cfa_offset 56 + + /* Restore the process state */ + mov edi, dword ptr [r15 + 8] + mov esi, dword ptr [r15 + 12] + mov ebp, dword ptr [r15 + 16] + mov ebx, dword ptr [r15 + 20] + mov edx, dword ptr [r15 + 24] + mov ecx, dword ptr [r15 + 28] + mov eax, dword ptr [r15 + 32] + mov r9d, dword ptr [r15 + 36] /* Emulated stack pointer */ + /* Don't restore the emulated pc */ + + // So that we can jump back into the top-level cache call. + mov [RIP + granary_stack_pointer], rsp + + /* Call into the block */ +.Lenter_cache: + call r14 + + /* Check the inline cache */ + pushfq + push r11 + + /* The target PC is NULL, this can trivially match against empty cache + * entries, and it's an error case, so we need to handle it properly. */ + test r10, r10 + jz .Lexit_cache + + /* After the call, r14 will be the index::Val of the last executed block. + * Check that this block doesn't end with a system call. */ + bt r14, 62 + jc .Lexit_cache + + /* Find the cache offset for the probes. We use the last branch PC to + * index into the inline cache, and scale it by the number of probes per + * cache entry. */ + mov r11d, dword ptr [r15 + 52] + and r11, 0x7ff + shl r11, 3 /* Scale by 8 bytes, the size of each entry. */ + lea r11, [r11 + gInlineCache] + +#define CHECK_CACHE(entry) \ + cmp dword ptr [r11 + (entry * 8)], r10d ; \ + jnz .Lentry_invalid ## entry ; \ + mov r14d, dword ptr [r11 + (entry * 8 + 4)] ; \ + jmp .Lre_enter_cache ; \ + \ + .Lentry_invalid ## entry: + + CHECK_CACHE(0) + CHECK_CACHE(1) + CHECK_CACHE(2) + CHECK_CACHE(3) + + jmp .Lexit_cache + +.Lre_enter_cache: + pop r11 + popfq + jmp .Lenter_cache + +.Lexit_cache: + pop r11 + popfq + + /* Save the process state */ + mov dword ptr [r15 + 8], edi + mov dword ptr [r15 + 12], esi + mov dword ptr [r15 + 16], ebp + mov dword ptr [r15 + 20], ebx + mov dword ptr [r15 + 24], edx + mov dword ptr [r15 + 28], ecx + mov dword ptr [r15 + 32], eax + mov dword ptr [r15 + 36], r9d /* Emulated stack pointer */ + mov dword ptr [r15 + 40], r10d /* Emulated program counter */ + + /* After the call, r14 will be the index::Val of the last executed block */ + mov rax, r14 + + /* Save the flags */ + pushf ; .cfi_def_cfa_offset 60 + pop word ptr [r15 + 44] ; .cfi_def_cfa_offset 56 + + /* Restore the Linux ABI caller-saved regs */ + pop r15 ; .cfi_def_cfa_offset 48 + pop r14 ; .cfi_def_cfa_offset 40 + pop r13 ; .cfi_def_cfa_offset 32 + pop r12 ; .cfi_def_cfa_offset 24 + pop rbp ; .cfi_def_cfa_offset 16 + pop rbx ; .cfi_def_cfa_offset 8 + + ret + .cfi_endproc + .size _ZN7granary5cache4CallEPNS_2os9Process32EPh, .-_ZN7granary5cache4CallEPNS_2os9Process32EPh + ud2 diff --git a/granary/arch/x86/coverage.S b/granary/arch/x86/coverage.S new file mode 100644 index 0000000..f24e33a --- /dev/null +++ b/granary/arch/x86/coverage.S @@ -0,0 +1,100 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + + .file "granary/arch/x86/coverage.S" + + .intel_syntax noprefix + .text + + .extern gPathEntries + .extern gNextPathEntry + .extern UpdateCoverageSet + .extern gInputIndex + + // r15 os::Process32 * Process32 object. + // r14 index::Value Meta-data about this block. + // r13 Scratch. + // r12 Scratch. + // r11 Scratch. + // r10 Addr32 EIP. + // r9 Addr32 ESP. + // r8 Addr64 64-bit base of 32-bit address space. + // + // void CoverPath(void); + + + // Add an entry to the path coverage list. If the list get full, then + // call into UpdateCoverageSet to flush it and reset. + .align 16 + .globl CoverPath + .type CoverPath, @function +CoverPath: + .cfi_startproc + pushf + + // If we haven't read any input then it's not possible to have any + // input-dependent code coverage. + cmp qword ptr [RIP + gInputIndex], 0 + jz done + + mov r13d, dword ptr [RIP + gNextPathEntry] + cmp r13, 4096 * 3 * 4 + jz update_coverage_map + +add_entry: + lea r11, [RIP + gPathEntries] + mov r12d, dword ptr [r15 + 52] // Prev branch EIP + + mov dword ptr [r11 + r13 + 0], r12d // Prev branch EIP. + mov dword ptr [r11 + r13 + 4], r14d // Block EIP + mov dword ptr [r11 + r13 + 8], r10d // Target EIP + + // Move to the next path entry. + add dword ptr [RIP + gNextPathEntry], 3 * 4 + +done: + popf + ret + +update_coverage_map: + push rax + push rbx + push rcx + push rdx + push rbp + push rsi + push rdi + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + + call UpdateCoverageSet + + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + pop rdi + pop rsi + pop rbp + pop rdx + pop rcx + pop rbx + pop rax + + mov dword ptr [RIP + gNextPathEntry], 0 + xor r13, r13 + jmp add_entry + + .cfi_endproc + .size CoverPath, .-CoverPath + ud2 + diff --git a/granary/arch/x86/cpu.cc b/granary/arch/x86/cpu.cc new file mode 100644 index 0000000..1f38f56 --- /dev/null +++ b/granary/arch/x86/cpu.cc @@ -0,0 +1,18 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/base/base.h" +#include "granary/base/breakpoint.h" + +namespace granary { +namespace arch { + +void Relax(void) { + GRANARY_INLINE_ASSEMBLY("pause;" ::: "memory"); +} + +void SerializePipeline(void) { + GRANARY_INLINE_ASSEMBLY("cpuid;" ::: "eax", "ebx", "ecx", "edx", "memory"); +} + +} // namespace arch +} // namespace granary diff --git a/granary/arch/x86/fault.cc b/granary/arch/x86/fault.cc new file mode 100644 index 0000000..8db4d9a --- /dev/null +++ b/granary/arch/x86/fault.cc @@ -0,0 +1,96 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#include "granary/arch/fault.h" +#include "granary/arch/x86/instruction.h" + +#include "granary/os/process.h" + +namespace granary { +namespace arch { +namespace { + +static uint32_t RegToVal(const os::Process32 *process, xed_reg_enum_t reg) { + switch (reg) { + case XED_REG_RAX: + case XED_REG_EAX: + return process->regs.eax; + case XED_REG_RCX: + case XED_REG_ECX: + return process->regs.ecx; + case XED_REG_RDX: + case XED_REG_EDX: + return process->regs.edx; + case XED_REG_RBX: + case XED_REG_EBX: + return process->regs.ebx; + case XED_REG_RSP: + case XED_REG_ESP: + return process->regs.esp; + case XED_REG_RBP: + case XED_REG_EBP: + return process->regs.ebp; + case XED_REG_RSI: + case XED_REG_ESI: + return process->regs.esi; + case XED_REG_RDI: + case XED_REG_EDI: + return process->regs.edi; + default: + return 0; + } +} + +} // namespace + +void DecomposeFaultAddr( + const os::Process32 *process, + Addr32 *base, + Addr32 *index, + Addr32 *scale, + Addr32 *disp, + Addr32 fault_addr) { + + *base = fault_addr; + *index = 0; + *scale = 0; + *disp = 0; + + uint8_t bytes[kMaxNumInstructionBytes] = {0}; + size_t size = 0; + for (auto i = 0U; i < kMaxNumInstructionBytes; ++i, ++size) { + auto addr = process->ConvertAddress(process->regs.eip + i); + auto pc = reinterpret_cast(addr); + if (!process->TryRead(pc, bytes[i])) { + break; + } + } + + if (!size) { + return; + } + + Instruction instr; + instr.TryDecode(bytes, size, ISA::x86); + + for (const auto &op : instr.operands) { + if (XED_ENCODER_OPERAND_TYPE_MEM == op.type) { + auto b = RegToVal(process, op.u.mem.base); + auto i = RegToVal(process, op.u.mem.index); + auto s = op.u.mem.scale; + auto d = static_cast(op.u.mem.disp.displacement); + + auto mem_addr = b + (i * s) + d; + if (mem_addr == fault_addr) { + *base = b; + *index = i; + *scale = s; + *disp = d; + return; + } + } + } +} + +} // namespace arch +} // namespace granary + diff --git a/granary/arch/x86/instruction.cc b/granary/arch/x86/instruction.cc new file mode 100644 index 0000000..b77b5e2 --- /dev/null +++ b/granary/arch/x86/instruction.cc @@ -0,0 +1,476 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/instruction.h" + +namespace granary { +namespace arch { + +extern const xed_state_t kXEDState32 = { + XED_MACHINE_MODE_LONG_COMPAT_32, + XED_ADDRESS_WIDTH_32b}; + +extern const xed_state_t kXEDState64 = { + XED_MACHINE_MODE_LONG_64, + XED_ADDRESS_WIDTH_64b}; + +namespace { + +// Returns true if we've marked a register as live in the GPR set. +static bool TryAddToGPRSet(GPRSet *set, xed_reg_enum_t reg64) { + switch (reg64) { + case XED_REG_RAX: set->gax = true; return true; + case XED_REG_RCX: set->gcx = true; return true; + case XED_REG_RDX: set->gdx = true; return true; + case XED_REG_RBX: set->gbx = true; return true; + case XED_REG_RSP: set->gsp = true; return true; + case XED_REG_RBP: set->gbp = true; return true; + case XED_REG_RSI: set->gsi = true; return true; + case XED_REG_RDI: set->gdi = true; return true; + case XED_REG_R8: set->r8 = true; return true; + case XED_REG_R9: set->r9 = true; return true; + case XED_REG_R10: set->r10 = true; return true; + case XED_REG_R11: set->r11 = true; return true; + case XED_REG_R12: set->r12 = true; return true; + case XED_REG_R13: set->r13 = true; return true; + case XED_REG_R14: set->r14 = true; return true; + case XED_REG_R15: set->r15 = true; return true; + default: return false; + } +} + +// Updates some GPR sets with a GPR. +static void UpdateGPRSets(Instruction *instr, xed_reg_enum_t reg, + xed_operand_action_enum_t action) { + auto reg64 = xed_get_largest_enclosing_register(reg); + switch (action) { + case XED_OPERAND_ACTION_RW: + case XED_OPERAND_ACTION_RCW: + case XED_OPERAND_ACTION_CRW: + TryAddToGPRSet(&(instr->gprs_read), reg64); + TryAddToGPRSet(&(instr->gprs_written), reg64); + break; + case XED_OPERAND_ACTION_R: + case XED_OPERAND_ACTION_CR: + TryAddToGPRSet(&(instr->gprs_read), reg64); + break; + + // Write-only operands are tricky because they might actually not write to + // the full register, so we want to represent a partial write as a read + // dependency. + case XED_OPERAND_ACTION_W: + case XED_OPERAND_ACTION_CW: + if (TryAddToGPRSet(&(instr->gprs_written), reg64) && + 32 > xed_get_register_width_bits64(reg)) { + TryAddToGPRSet(&(instr->gprs_read), reg64); + } + break; + + default: break; + } +} + +// Decode a memory operand. +// +// Note: This only applies to `MEM0` operands. +static xed_encoder_operand_t DecodeMemory0(const xed_decoded_inst_t *xedd, + Instruction *instr, + xed_operand_enum_t op_name, + unsigned op_num) { + xed_encoder_operand_t op; + op.type = XED_ENCODER_OPERAND_TYPE_MEM; + op.u.mem.seg = xed_decoded_inst_get_seg_reg(xedd, 0); + op.u.mem.base = xed_decoded_inst_get_base_reg(xedd, 0); + op.u.mem.index = xed_decoded_inst_get_index_reg(xedd, 0); + op.u.mem.disp.displacement = \ + xed_decoded_inst_get_memory_displacement(xedd, 0); + op.u.mem.disp.displacement_width = \ + xed_decoded_inst_get_memory_displacement_width_bits(xedd, 0); + op.u.mem.scale = xed_decoded_inst_get_scale(xedd, 0); + op.width = xed_decoded_inst_operand_length_bits(xedd, op_num) ?: + instr->effective_operand_width; + auto base64 = xed_get_largest_enclosing_register(op.u.mem.base); + auto index64 = xed_get_largest_enclosing_register(op.u.mem.base); + + if (XED_REG_RIP == base64) instr->has_pc_rel_op = true; + if (XED_REG_RIP == index64) instr->has_pc_rel_op = true; + + TryAddToGPRSet(&(instr->gprs_written), base64); + TryAddToGPRSet(&(instr->gprs_written), index64); + + if (XED_OPERAND_AGEN != op_name) { + instr->reads_mem = xed_decoded_inst_mem_read(xedd, 0); + instr->writes_mem = xed_decoded_inst_mem_written(xedd, 0); + } + return op; +} + +// Decode `IMM0` operands. +static xed_encoder_operand_t DecodeImm0(const xed_decoded_inst_t *xedd, + xed_operand_enum_t op_name) { + xed_encoder_operand_t op; + if (XED_OPERAND_IMM0SIGNED == op_name || + xed_operand_values_get_immediate_is_signed(xedd)) { + op.type = XED_ENCODER_OPERAND_TYPE_SIMM0; + op.u.imm0 = static_cast(static_cast( + xed_decoded_inst_get_signed_immediate(xedd))); + } else { + op.type = XED_ENCODER_OPERAND_TYPE_IMM0; + op.u.imm0 = xed_decoded_inst_get_unsigned_immediate(xedd); + } + op.width = xed_decoded_inst_get_immediate_width_bits(xedd); + return op; +} + +// Decode `IMM1` operands. +static xed_encoder_operand_t DecodeImm1(const xed_decoded_inst_t *xedd) { + xed_encoder_operand_t op; + op.type = XED_ENCODER_OPERAND_TYPE_IMM1; + op.u.imm1 = xed_decoded_inst_get_second_immediate(xedd); + op.width = xed_decoded_inst_get_immediate_width_bits(xedd); + return op; +} + +// Pull out a pointer operand. These are used in things like call/jmp far. +static xed_encoder_operand_t DecodePtr(const xed_decoded_inst_t *) { + //GRANARY_ASSERT(false && "Unexpected PTR operand."); + // TODO(pag): Unimplemented. + //return {}; + xed_encoder_operand_t op; + op.type = XED_ENCODER_OPERAND_TYPE_INVALID; + return op; +} + +// Pull out a register operand from the XED instruction. +static xed_encoder_operand_t DecodeReg(const xed_decoded_inst_t *xedd, + const xed_operand_t *xedo, + Instruction *instr, + const xed_operand_enum_t op_name) { + xed_encoder_operand_t op; + op.type = XED_ENCODER_OPERAND_TYPE_REG; + op.u.reg = xed_decoded_inst_get_reg(xedd, op_name); + if (XED_REG_AH <= op.u.reg && op.u.reg <= XED_REG_BH) { + instr->uses_legacy_registers = true; + } + if (XED_ADDRESS_WIDTH_64b == instr->mode.stack_addr_width) { + op.width = xed_get_register_width_bits64(op.u.reg); + } else { + op.width = xed_get_register_width_bits(op.u.reg); + } + UpdateGPRSets(instr, op.u.reg, xed_operand_rw(xedo)); + return op; +} + +// Pull out a relative branch target. +static xed_encoder_operand_t DecodeRelbr(const xed_decoded_inst_t *xedd) { + xed_encoder_operand_t op; + op.type = XED_ENCODER_OPERAND_TYPE_BRDISP; + op.u.brdisp = xed_decoded_inst_get_branch_displacement(xedd); + op.width = xed_decoded_inst_get_branch_displacement_width_bits(xedd); + return op; +} + +// Converts a `xed_operand_t` into an operand in `instr`. +static void DecodeOperand(const xed_decoded_inst_t *xedd, + const xed_operand_t *xedo, + Instruction *instr) { + auto op_num = instr->noperands++; + auto &op = instr->operands[op_num]; + switch (auto op_name = xed_operand_name(xedo)) { + case XED_OPERAND_AGEN: + case XED_OPERAND_MEM0: + op = DecodeMemory0(xedd, instr, op_name, op_num); + break; + + case XED_OPERAND_IMM0SIGNED: + case XED_OPERAND_IMM0: + op = DecodeImm0(xedd, op_name); + break; + + case XED_OPERAND_IMM1_BYTES: + case XED_OPERAND_IMM1: + op = DecodeImm1(xedd); + break; + + case XED_OPERAND_PTR: + op = DecodePtr(xedd); + break; + + case XED_OPERAND_REG0: + case XED_OPERAND_REG1: + case XED_OPERAND_REG2: + case XED_OPERAND_REG3: + op = DecodeReg(xedd, xedo, instr, op_name); + break; + + case XED_OPERAND_RELBR: + op = DecodeRelbr(xedd); + instr->has_pc_rel_op = true; + break; + + // TODO(pag): Handle `XED_OPERAND_IMM1_BYTES`? + default: + GRANARY_ASSERT(false && "Unexpected operand type for encoding."); + return; + } +} + +// Update flags in the instruction that track registers and arithmetic flags. +static void UpdateFlags(const xed_decoded_inst_t *xedd, + const xed_operand_t *xedo, Instruction *instr) { + switch (auto op_name = xed_operand_name(xedo)) { + case XED_OPERAND_REG: + case XED_OPERAND_REG0: + case XED_OPERAND_REG1: + case XED_OPERAND_REG2: + case XED_OPERAND_REG3: + case XED_OPERAND_REG4: + case XED_OPERAND_REG5: + case XED_OPERAND_REG6: + case XED_OPERAND_REG7: + case XED_OPERAND_REG8: { + auto reg = xed_decoded_inst_get_reg(xedd, op_name); + if (XED_REG_AH <= reg && reg <= XED_REG_BH) { + instr->uses_legacy_registers = true; + } + switch (reg) { + case XED_REG_STACKPUSH: + case XED_REG_STACKPOP: + instr->gprs_read.gsp = true; + instr->gprs_written.gsp = true; + break; + + case XED_REG_FLAGS: + case XED_REG_EFLAGS: + case XED_REG_RFLAGS: + instr->reads_aflags = xed_operand_read(xedo); + instr->writes_aflags = xed_operand_written(xedo); + break; + + default: + UpdateGPRSets(instr, reg, xed_operand_rw(xedo)); + break; + } + break; + } + default: break; + } +} + +// Converts a `xed_decoded_inst_t` into an `Instruction`. +static void DecodeOperands(const xed_decoded_inst_t *xedd, + const xed_inst_t *xedi, Instruction *instr) { + auto num_ops = xed_inst_noperands(xedi); + for (auto i = 0U; i < num_ops; ++i) { + auto xedo = xed_inst_operand(xedi, i); + switch (xed_operand_operand_visibility(xedo)) { + case XED_OPVIS_EXPLICIT: + case XED_OPVIS_IMPLICIT: + DecodeOperand(xedd, xedo, instr); + break; + case XED_OPVIS_SUPPRESSED: + UpdateFlags(xedd, xedo, instr); + break; + default: return; + } + } +} + +// Decode the prefixes. We purposely ignore branch taken/not taken hints. +static void DecodePrefixes(const xed_decoded_inst_t *xedd, Instruction *instr) { + if (xed_operand_values_has_real_rep(xedd)) { + instr->prefixes.s.rep = xed_operand_values_has_rep_prefix(xedd); + instr->prefixes.s.repne = xed_operand_values_has_repne_prefix(xedd); + } + instr->prefixes.s.lock = xed_operand_values_has_lock_prefix(xedd); + + // TODO(pag): XACQUIRE, XRELEASE, MPX. +} + +// Do an actual decoding of up to `num_bytes` bytes. +static bool DoDecode(xed_decoded_inst_t *xedd, const xed_state_t *dstate, + const void *pc_, unsigned num_bytes) { + xed_decoded_inst_zero_set_mode(xedd, dstate); + xed_decoded_inst_set_input_chip(xedd, XED_CHIP_INVALID); + auto pc = reinterpret_cast(pc_); + if (XED_ERROR_NONE != xed_decode(xedd, pc, num_bytes)) { + return false; + } + switch (xed_decoded_inst_get_category(xedd)) { + case XED_CATEGORY_AES: + case XED_CATEGORY_AVX: + case XED_CATEGORY_AVX2: + case XED_CATEGORY_AVX2GATHER: + case XED_CATEGORY_AVX512: + case XED_CATEGORY_AVX512VBMI: + case XED_CATEGORY_RDRAND: + case XED_CATEGORY_RDSEED: + return false; + default: + return true; + } +} + +// Makes an undefined instruction. +static void MakeUD2(Instruction *instr, ISA isa) { + auto state = ISA::x86 == isa ? kXEDState32 : kXEDState64; + xed_inst0(instr, state, XED_ICLASS_UD2, 0); + instr->decoded_length = 2; + instr->bytes[0] = 0x0F; + instr->bytes[1] = 0x0B; + instr->is_valid = true; +} + +// Set of registers, in the reverse order from what they appear in the GPRSet, +// such that the index of a register in this array corresponds to the bit +// position of the register in the GPRSet. +static xed_reg_enum_t gGprsInSet[] = { + XED_REG_RSP, + XED_REG_RAX, + XED_REG_RCX, + XED_REG_RDX, + XED_REG_RBX, + XED_REG_RBP, + XED_REG_RSI, + XED_REG_RDI, + XED_REG_R8, + XED_REG_R9, + XED_REG_R10, + XED_REG_R11, + XED_REG_R12, + XED_REG_R13, + XED_REG_R14, + XED_REG_R15 +}; + +// Try to verify that all operands were successfully decoded. +// +// TODO(pag): This is ugly. That is, our only way of signaling a failure to +// decode an operand is via its operand type. +static bool VerifyDecodedOperands(const Instruction *instr) { + for (auto i = 0U; i < instr->noperands; ++i) { + const auto &op = instr->operands[i]; + if (XED_ENCODER_OPERAND_TYPE_INVALID == op.type) return false; + } + return true; +} + +} // namespace + +// Revives and returns the next dead register in the register set. +xed_reg_enum_t GPRSet::ReviveNextDeadReg(void) { + for (auto i = 0U; i < 16U; ++i) { + auto bit = 1U << i; + if (!(bit & bits)) { + bits |= bit; + return gGprsInSet[16 - i]; + } + } + return XED_REG_INVALID; +} + +// Decode an instruction. +bool Instruction::TryDecode(const uint8_t *decode_bytes, size_t max_num_bytes, + ISA isa) { + xed_decoded_inst_t xedd; + memset(this, 0, sizeof *this); + + auto state = ISA::x86 == isa ? &kXEDState32 : &kXEDState64; + max_num_bytes = std::min(kMaxNumInstructionBytes, max_num_bytes); + + // If we come across an invalid instruction, then we'll propagate it out to + // the real code so that a `SIGILL` in native code turns into a `SIGILL` in + // translated code. + if (!max_num_bytes || !DoDecode(&xedd, state, decode_bytes, max_num_bytes)) { + MakeUD2(this, isa); + return false; + } + + decoded_length = xed_decoded_inst_get_length(&xedd); + is_valid = true; // Assume there are no PC-relative references. + + iclass = xed_decoded_inst_get_iclass(&xedd); + + // Good defaults, will fixup special cases later. + effective_address_width = AddressWidth(); + effective_operand_width = xed_decoded_inst_get_operand_width(&xedd); + + memcpy(bytes, decode_bytes, decoded_length); + DecodePrefixes(&xedd, this); + DecodeOperands(&xedd, xed_decoded_inst_inst(&xedd), this); + return VerifyDecodedOperands(this); +} + +namespace { +// Perform the actual encoding of an instruction. +static bool DoEncode(Instruction *instr, uint8_t *bytes) { + if (XED_ICLASS_JECXZ == instr->iclass) { + bytes[0] = 0x67; + bytes[1] = 0xe3; + bytes[2] = static_cast(instr->operands[0].u.brdisp); + return true; + } else { + xed_encoder_request_t xede; + xed_encoder_request_zero_set_mode(&xede, &(instr->mode)); + if (!xed_convert_to_encoder_request(&xede, instr)) return false; + return XED_ERROR_NONE == xed_encode(&xede, bytes, kMaxNumInstructionBytes, + &(instr->encoded_length)); + } +} +} // namespace + +size_t Instruction::NumEncodedBytes(void) { + if (!DoEncode(this, bytes)) return 0; + is_valid = true; + return encoded_length; +} + +// Copies an already encoded version of the instruction to `encode_pc`, or +// encodes it directly into the right location. +void Instruction::Encode(CachePC encode_pc) { + if (encoded_length && is_valid) { + memcpy(encode_pc, bytes, encoded_length); + } else { + is_valid = DoEncode(this, encode_pc); + } +} + +// See: http://www.sandpile.org/x86/coherent.htm +bool Instruction::IsSerializing(void) const { + switch (iclass) { + case XED_ICLASS_IRET: + case XED_ICLASS_IRETD: + case XED_ICLASS_IRETQ: + case XED_ICLASS_RSM: + case XED_ICLASS_CPUID: + case XED_ICLASS_LGDT: + case XED_ICLASS_LIDT: + case XED_ICLASS_LLDT: + case XED_ICLASS_LTR: + case XED_ICLASS_INVLPG: + case XED_ICLASS_INVLPGA: + case XED_ICLASS_INVEPT: + case XED_ICLASS_INVVPID: + case XED_ICLASS_INVD: + case XED_ICLASS_WBINVD: + case XED_ICLASS_LMSW: + case XED_ICLASS_WRMSR: + case XED_ICLASS_SWAPGS: + case XED_ICLASS_INT1: + case XED_ICLASS_INT3: + case XED_ICLASS_INTO: + case XED_ICLASS_INT: + case XED_ICLASS_LDS: + case XED_ICLASS_LSS: + case XED_ICLASS_LGS: + case XED_ICLASS_LES: + case XED_ICLASS_LFS: + return true; + + // TODO(pag): Check things like `MOV SS, ...`. + default: + return false; + } +} + +} // namespace arch +} // namespace granary diff --git a/granary/arch/x86/instruction.h b/granary/arch/x86/instruction.h new file mode 100644 index 0000000..b9f4f3b --- /dev/null +++ b/granary/arch/x86/instruction.h @@ -0,0 +1,215 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_X86_INSTRUCTION_H_ +#define GRANARY_ARCH_X86_INSTRUCTION_H_ + +#include "granary/arch/isa.h" +#include "granary/arch/x86/xed-intel64.h" + +#include "granary/base/base.h" + +namespace granary { +namespace arch { + +enum { + // Maximum number of bytes in an x86/x64 instruction. + kMaxNumInstructionBytes = 15, + + kAddrWidthBytes_x86 = 4, + kAddrWidthBits_x86 = 32, + kAddrWidthBytes_amd64 = 8, + kAddrWidthBits_amd64 = 64 +}; + +// Bit set of all general purpose registers. +union GPRSet { + struct { + bool r15:1; + bool r14:1; + bool r13:1; + bool r12:1; + bool r11:1; + bool r10:1; + bool r9:1; + bool r8:1; + bool gdi:1; + bool gsi:1; + bool gbp:1; + bool gbx:1; + bool gdx:1; + bool gcx:1; + bool gax:1; + bool gsp:1; + } __attribute__((packed)); + + uint16_t bits; + + // Revives and returns the next dead register in the register set. + xed_reg_enum_t ReviveNextDeadReg(void); +}; + +static_assert(sizeof(GPRSet) == sizeof(uint16_t), + "Invalid structure packing of `union GPRSet`."); + +// Represents an instruction. +struct Instruction final : public xed_encoder_instruction_t { + inline bool IsFunctionCall(void) const { + return XED_ICLASS_CALL_NEAR == iclass || XED_ICLASS_CALL_FAR == iclass; + } + + inline bool IsFunctionReturn(void) const { + return XED_ICLASS_RET_NEAR == iclass || XED_ICLASS_RET_FAR == iclass; + } + + // TODO(pag): Add support for ABI-specific system calls (e.g. `int 0x80`). + // TODO(pag): What about call gates? + inline bool IsSystemCall(void) const { + return XED_ICLASS_SYSCALL == iclass || XED_ICLASS_SYSCALL_AMD == iclass || + XED_ICLASS_SYSENTER == iclass; + } + + inline bool IsSystemReturn(void) const { + return XED_ICLASS_SYSRET == iclass || XED_ICLASS_SYSRET_AMD == iclass || + XED_ICLASS_SYSEXIT == iclass; + } + + inline bool IsInterruptCall(void) const { + return XED_ICLASS_INT <= iclass && XED_ICLASS_INTO >= iclass; + } + + inline bool IsInterruptReturn(void) const { + return XED_ICLASS_IRET <= iclass && XED_ICLASS_IRETQ >= iclass; + } + + // This includes `JRCXZ`. + inline bool IsBranch(void) const { + return (XED_ICLASS_JB <= iclass && XED_ICLASS_JLE >= iclass) || + (XED_ICLASS_JNB <= iclass && XED_ICLASS_JZ >= iclass) || + (XED_ICLASS_LOOP <= iclass && XED_ICLASS_LOOPNE >= iclass) || + XED_ICLASS_XBEGIN == iclass; + } + + inline bool IsJump(void) const { + return XED_ICLASS_JMP == iclass || XED_ICLASS_JMP_FAR == iclass || + XED_ICLASS_XEND == iclass || XED_ICLASS_XABORT == iclass; + } + + inline bool IsDirectFunctionCall(void) const { + return XED_ICLASS_CALL_NEAR == iclass && + XED_ENCODER_OPERAND_TYPE_BRDISP == operands[0].type; + } + + inline bool IsIndirectFunctionCall(void) const { + return (XED_ICLASS_CALL_NEAR == iclass && + XED_ENCODER_OPERAND_TYPE_BRDISP != operands[0].type) || + XED_ICLASS_CALL_FAR == iclass; + } + + inline bool IsDirectJump(void) const { + return XED_ICLASS_JMP == iclass && + XED_ENCODER_OPERAND_TYPE_BRDISP == operands[0].type; + } + + inline bool IsIndirectJump(void) const { + return (XED_ICLASS_JMP == iclass && + XED_ENCODER_OPERAND_TYPE_BRDISP != operands[0].type) || + XED_ICLASS_JMP_FAR == iclass || + XED_ICLASS_XEND == iclass || XED_ICLASS_XABORT == iclass; + } + + // Returns true if this instruction has a side-effect of serializing the + // instruction pipeline. This class of instruction is significant for self- + // and cross-modifying code. + bool IsSerializing(void) const; + + // Is the instruction an undefined instruction? + bool IsUndefined(void) const { + return XED_ICLASS_INVALID == iclass || XED_ICLASS_UD2 == iclass; + } + + // Target PC of a control-flow instruction. + inline AppPC32 TargetPC(void) const { + return EndPC() + operands[0].u.brdisp; + } + + // Set the starting application PC of this instruction. + inline void SetStartPC(AppPC32 pc) { + decoded_pc = pc; + } + + // Beginning program counter of this instruction. + inline AppPC32 StartPC(void) const { + return decoded_pc; + } + + // Program counter of the next logical instruction after this instruction. + inline AppPC32 EndPC(void) const { + return decoded_pc + decoded_length; + } + + // Size of this instruction in bytes. + inline size_t NumBytes(void) const { + return decoded_length; + } + + // Try to decode an instruction starting at `decode_pc`. + bool TryDecode(const uint8_t *decode_bytes, size_t max_num_bytes, ISA isa); + + // Computes the encoded length of the instruction. + size_t NumEncodedBytes(void); + + // Actually encode an instruction. This assumes that `TryEncode` returned + // `true`. + void Encode(CachePC encode_pc); + + union { + AppPC32 decoded_pc; + }; + + union { + unsigned decoded_length; + unsigned encoded_length; + }; + + // General purpose registers read and written by this instruction. We treat + // conditional reads/writes as unconditional, and we treat writes that don't + // overwrite the full register state as being reads as well. + GPRSet gprs_read; + GPRSet gprs_written; + + struct { + // Are the bytes in `bytes` valid? If so, then we can just copy them. Things + // that make them invalid would be modification, which usually happens for + // PC-relative operands. + bool is_valid:1; + + // Does this instruction have a PC-relative operand? + bool has_pc_rel_op:1; + + // Does this instruction have a PC-relative operand that needs to be re- + // encoded? + bool reencode_pc_rel_op:1; + + // Does this instruction read/write to/from the arithmetic flags? We're + // conservative and don't particularly care what flags are read/written. + bool reads_aflags:1; + bool writes_aflags:1; + + // Does this use "legacy" 32- or 16-bit registers? If so, then this + // instruction likely cannot also use newer 64-bit registers (r8-r15). + bool uses_legacy_registers:1; + + // Does this instruction read from or write to memory? + bool reads_mem:1; + bool writes_mem:1; + + } __attribute__((packed)); + + // Encoded or decoded bytes. + uint8_t bytes[kMaxNumInstructionBytes]; +}; + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_X86_INSTRUCTION_H_ diff --git a/granary/arch/x86/instrument.cc b/granary/arch/x86/instrument.cc new file mode 100644 index 0000000..f7cbb21 --- /dev/null +++ b/granary/arch/x86/instrument.cc @@ -0,0 +1,49 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/instruction.h" +#include "granary/arch/instrument.h" + +namespace granary { +namespace arch { + +extern const xed_state_t kXEDState64; + +namespace { + +static CachePC gInstFuncs[code::InstrumentationPoint::kInvalid] = {nullptr}; + +} // namespace + +// Initialize instrumentation routines for use within basic blocks. +void InitInstrumentationFunctions(CachePC instrument_section) { + auto ipoint_max = static_cast(code::InstrumentationPoint::kInvalid); + for (auto i = 0; i < ipoint_max; ++i) { + arch::Instruction instr; + memset(&instr, 0, sizeof instr); + memset(instrument_section, 0x90, 8); + + auto ipoint = static_cast(i); + if (auto addr = code::GetInstrumentationFunction(ipoint)) { + auto next_pc = instrument_section + 5; + auto target_pc = reinterpret_cast(addr); + xed_inst1(&instr, arch::kXEDState64, XED_ICLASS_JMP, + kAddrWidthBits_amd64, xed_relbr(target_pc - next_pc, 32)); + } else { + xed_inst0(&instr, arch::kXEDState64, XED_ICLASS_RET_NEAR, + kAddrWidthBits_amd64); + } + gInstFuncs[ipoint] = instrument_section; + instr.Encode(instrument_section); + instrument_section += 8; + } +} + +// Returns the location in the code cache of where this instrumentation +// function is. +CachePC GetInstrumentationFunction(code::InstrumentationPoint ipoint) { + GRANARY_ASSERT(code::InstrumentationPoint::kInvalid != ipoint); + return gInstFuncs[ipoint]; +} + +} // namespace arch +} // namespace granary diff --git a/granary/arch/x86/patch.cc b/granary/arch/x86/patch.cc new file mode 100644 index 0000000..099f13e --- /dev/null +++ b/granary/arch/x86/patch.cc @@ -0,0 +1,173 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/x86/patch.h" + +#include "granary/os/process.h" + +#include "granary/code/cache.h" +#include "granary/code/index.h" + +#include +#include +#include +#include + +#include + +DECLARE_bool(persist); +DECLARE_string(persist_dir); + +DEFINE_bool(disable_patching, false, + "Disable hot-patching of conditional branches?"); + +namespace granary { +namespace arch { +namespace { + +struct PatchPoint { + CacheOffset patch_offset; + index::Key target; +}; + +enum { + // After how many patch points should we try to patch? + kPatchInterval = 64, + + // How many patch points should we store? + kNumPatches = (2 * os::kPageSize) / sizeof(PatchPoint) +}; + +static_assert(!(kNumPatches % kPatchInterval), "Invalid patch interval."); + +// Array of all patch points. +// +// Note: `+ 1` is so that `mmap` won't overflow and corrupt some other memory. +alignas(os::kPageSize) static PatchPoint gPatches[kNumPatches + 1]; + +// Offset of the next patch point that can be assigned. +static int gNextPatch = 0; + +// FD for the patch file. +static int gFd = -1; + +// Patch a jump in the code. +// +// Note: `patch_offset` is the offset of an `int32_t` in the code cache that +// immediately follows the `JMP` opcode. +static void Patch(CacheOffset patch_offset, index::Value target) { + auto next_pc = cache::OffsetToPC(patch_offset + 4 /* sizeof(CacheOffset) */); + auto target_pc = cache::OffsetToPC(target.cache_offset); + auto offset_diff = static_cast(target_pc - next_pc); + auto rel32 = reinterpret_cast(reinterpret_cast( + cache::OffsetToPC(patch_offset))); + offset_diff = __sync_lock_test_and_set(rel32, offset_diff); + // It should have had a zero value (e.g. `JMP next_pc`). + GRANARY_ASSERT(!offset_diff); +} + +// Clear all patch points. +static void ClearPatchPoints(void) { + memset(gPatches, 0, sizeof gPatches); + gNextPatch = 0; +} + + +// Type to patch all patch points. +static void PatchCode(void) { + auto first_free = 0; + auto last_free = 0; + auto patched = false; + for (auto i = 0; i < gNextPatch; ++i) { + auto &patch = gPatches[i]; + + // A patch point that we can patch. + if (auto val = index::Find(patch.target)) { + Patch(patch.patch_offset, val); + memset(&patch, 0, sizeof patch); + ++last_free; + patched = true; + + // A patch point that we can't patch yet. Bubble it to a different + // position. + } else if (first_free != last_free) { + memcpy(&(gPatches[first_free]), &patch, sizeof patch); + memset(&patch, 0, sizeof patch); + ++first_free; + ++last_free; + + // A patch point that we can't patch yet. There are free slots available + // to which we can bubble this + } else { + ++first_free; + ++last_free; + } + } + if (patched) { + cache::ClearInlineCache(); + } + gNextPatch = first_free; +} + +} // namespace + +// Add a new patch point. +void AddPatchPoint(CachePC rel32, AppPC32 target) { + if (FLAGS_disable_patching) { + return; + } + if (gNextPatch && !(gNextPatch % kPatchInterval)) { + PatchCode(); + if (GRANARY_UNLIKELY(kNumPatches == gNextPatch)) ClearPatchPoints(); + } + + auto &patch = gPatches[gNextPatch++]; + patch.patch_offset = cache::PCToOffset(reinterpret_cast( + reinterpret_cast(rel32))); + patch.target = index::Key(os::gProcess, target); +} + +void InitPatcher(void) { + auto flags = MAP_FIXED | MAP_32BIT; + if (FLAGS_persist) { + + static char gPath[256] = {'\0'}; + sprintf(gPath, "%s/grr.patch.persist", FLAGS_persist_dir.c_str()); + + GRANARY_IF_ASSERT( errno = 0; ) + gFd = open(gPath, O_RDWR | O_CLOEXEC | O_CREAT | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open patch file."); + + ftruncate(gFd, os::kPageSize); + flags |= MAP_SHARED; + + } else { + gFd = -1; + flags |= MAP_PRIVATE | MAP_ANONYMOUS; + } + + GRANARY_IF_ASSERT( errno = 0; ) + mmap(&gPatches, os::kPageSize, PROT_READ | PROT_WRITE, flags, gFd, 0); + GRANARY_ASSERT(!errno && "Unable to map patch file."); + + // Advance the patch offset. + for (; gNextPatch < kNumPatches; ++gNextPatch) { + if (!gPatches[gNextPatch].target) break; + } +} + +void ExitPatcher(void) { + if (FLAGS_persist) { + PatchCode(); + msync(gPatches, os::kPageSize, MS_SYNC | MS_INVALIDATE); + } + + munmap(gPatches, os::kPageSize); + + if (FLAGS_persist) { + fsync(gFd); + close(gFd); + } +} + +} // namespace arch +} // namespace granary diff --git a/granary/arch/x86/patch.h b/granary/arch/x86/patch.h new file mode 100644 index 0000000..6e8060c --- /dev/null +++ b/granary/arch/x86/patch.h @@ -0,0 +1,17 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/arch/patch.h" + +#ifndef GRANARY_ARCH_X86_PATCH_H_ +#define GRANARY_ARCH_X86_PATCH_H_ + +namespace granary { +namespace arch { + +// Add a new patch point. +void AddPatchPoint(CachePC rel32, AppPC32 target); + +} // namespace arch +} // namespace granary + +#endif // GRANARY_ARCH_X86_PATCH_H_ diff --git a/granary/arch/x86/process.cc b/granary/arch/x86/process.cc new file mode 100644 index 0000000..cb1b876 --- /dev/null +++ b/granary/arch/x86/process.cc @@ -0,0 +1,195 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/process.h" +#include "granary/os/snapshot.h" + +#include "granary/code/cache.h" +#include "granary/code/execute.h" + +namespace granary { +namespace os { + +// Tries to do a write of a specific size. +bool Process32::DoTryWrite(uint32_t *ptr, uint32_t val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "mov %0, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(val), "r"(ptr) + : "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +bool Process32::DoTryWrite(uint16_t *ptr, uint16_t val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "movw %0, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(val), "r"(ptr) + : "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +bool Process32::DoTryWrite(uint8_t *ptr, uint8_t val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "movb %0, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(val), "r"(ptr) + : "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +// Tries to do a read of a specific size. +bool Process32::DoTryRead(const uint32_t *ptr, uint32_t *val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "mov (%0), %%r12d;" + "mov %%r12d, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(ptr), "r"(val) + : "r12", "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +bool Process32::DoTryRead(const uint16_t *ptr, uint16_t *val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "movw (%0), %%r12w;" + "movw %%r12w, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(ptr), "r"(val) + : "r12", "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +bool Process32::DoTryRead(const uint8_t *ptr, uint8_t *val) const { + PushProcess32 set_process(this); + fault_can_recover = true; + __asm__ __volatile__ ( + "jmp 1f;" + ".align 16, 0x90;" + "1:" + "movb (%0), %%r12b;" + "movb %%r12b, (%1);" + "jmp 2f;" + ".align 16, 0x90;" + "2:" + : + : "r"(ptr), "r"(val) + : "r12", "memory" + ); + auto ret = fault_can_recover; + fault_can_recover = false; + return ret; +} + +// Returns true if a signal handler can recover from this fault by returning. +bool Process32::RecoverFromTryReadWrite(ucontext_t *context) const { + if (!fault_can_recover) return false; + fault_can_recover = false; + auto &pc = context->uc_mcontext.gregs[REG_RIP]; + GRANARY_ASSERT(pc == (pc & ~15LL) && "Crash wasn't in a TryRead/TryWrite."); + pc += 16LL; + return true; +} + +// Initialize the register state. +void Process32::InitRegs(const Snapshot32 *snapshot) { + auto file = snapshot->file; + + regs.edi = static_cast(file->meta.gregs.rdi); + regs.esi = static_cast(file->meta.gregs.rsi); + regs.ebp = static_cast(file->meta.gregs.rbp); + regs.ebx = static_cast(file->meta.gregs.rbx); + regs.edx = static_cast(file->meta.gregs.rdx); + regs.ecx = static_cast(file->meta.gregs.rcx); + regs.eax = static_cast(file->meta.gregs.rax); + regs.esp = static_cast(file->meta.gregs.rsp); + regs.eip = static_cast(file->meta.gregs.rip); + regs.eflags = static_cast(file->meta.gregs.eflags); + + memcpy(&fpregs, &(file->meta.fpregs), sizeof fpregs); + last_branch_pc = 0; +} + +void Process32::SynchronizeRegState(ucontext_t *context) { + regs.edi = static_cast(context->uc_mcontext.gregs[REG_RDI]); + regs.esi = static_cast(context->uc_mcontext.gregs[REG_RSI]); + regs.ebp = static_cast(context->uc_mcontext.gregs[REG_RBP]); + regs.ebx = static_cast(context->uc_mcontext.gregs[REG_RBX]); + regs.edx = static_cast(context->uc_mcontext.gregs[REG_RDX]); + regs.ecx = static_cast(context->uc_mcontext.gregs[REG_RCX]); + regs.eax = static_cast(context->uc_mcontext.gregs[REG_RAX]); + regs.esp = static_cast(context->uc_mcontext.gregs[REG_R9]); + regs.eip = static_cast(context->uc_mcontext.gregs[REG_R10]); + regs.eflags = static_cast(context->uc_mcontext.gregs[REG_EFL]); +} + +void Process32::RestoreFPUState(void) const { + __asm__ __volatile__ ( + "fxrstor %0" + : + : "m"(fpregs) + : "memory"); +} + +void Process32::SaveFPUState(void) { + __asm__ __volatile__ ( + "fxsave %0" + : + : "m"(fpregs) + : "memory"); +} +} // namespace os +} // namespace granary diff --git a/granary/arch/x86/syscall.S b/granary/arch/x86/syscall.S new file mode 100644 index 0000000..bf4948e --- /dev/null +++ b/granary/arch/x86/syscall.S @@ -0,0 +1,17 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + + .file "granary/arch/x86/syscall.S" + .intel_syntax noprefix + .text + + // NextAppPC32 cache::Call(os::Process32 *process, CachePC block); + .align 16 + .globl sys_sigreturn; + .type sys_sigreturn, @function +sys_sigreturn: + .cfi_startproc + mov eax, 15 // `__NR_rt_sigreturn`. + syscall + .cfi_endproc + .size sigreturn, .-sigreturn + ud2 diff --git a/granary/arch/x86/trace.cc b/granary/arch/x86/trace.cc new file mode 100644 index 0000000..dea07d8 --- /dev/null +++ b/granary/arch/x86/trace.cc @@ -0,0 +1,77 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/trace.h" + +#include "granary/arch/cpu.h" + +#include "granary/code/cache.h" +#include "granary/code/instruction.h" + +namespace granary { +namespace arch { +extern const xed_state_t kXEDState64; +} // namespace arch +namespace { +enum : size_t { + kRelCallJmpSize = 5 +}; + +static void AddInstr(arch::InstructionStack &stack, const TraceEntry &entry, + CachePC next_pc, xed_iclass_enum_t iclass) { + auto instr = stack.Add(); + auto pc = cache::OffsetToPC(entry.val.cache_offset); + xed_inst1(instr, arch::kXEDState64, iclass, 64, xed_relbr(pc - next_pc, 32)); +} + +} // namespace + +void TraceRecorder::Build(void) { + if (1 >= trace_length) { + trace_length = 0; + return; + } + + cache::ClearInlineCache(); + + auto trace_size = trace_length * kRelCallJmpSize; // 5 bytes per CALL/JMP. + auto trace_begin = cache::Allocate(trace_size); + auto trace_end = trace_begin + trace_size; + + arch::InstructionStack stack; + auto i = trace_length - 1; + + // Create the intermediate trace instructions. + AddInstr(stack, entries[i], trace_end, XED_ICLASS_JMP); + for (; i-- > 0; ) { + trace_end -= kRelCallJmpSize; + AddInstr(stack, entries[i], trace_end, XED_ICLASS_CALL_NEAR); + } + + // Encode the trace instructions. + trace_end = trace_begin; + for (auto &einstr : stack) { + einstr.Encode(trace_end); + trace_end += kRelCallJmpSize; + } + + arch::SerializePipeline(); + + // Update the index with the new values. + auto last_val = entries[trace_length - 1].val; + for (i = 0; i < trace_length - 1; ++i) { + auto key = entries[i].key; + auto val = entries[i].val; + val.is_trace_head = (0 == i); + val.is_trace_block = true; + val.ends_with_syscall = last_val.ends_with_syscall; + val.has_one_successor = last_val.has_one_successor; + val.block_pc32 = last_val.block_pc32; + val.cache_offset = cache::PCToOffset(trace_begin); + trace_begin += kRelCallJmpSize; + index::Insert(key, val); + } + + trace_length = 0; +} + +} // namespace granary diff --git a/granary/arch/x86/xed-intel64.h b/granary/arch/x86/xed-intel64.h new file mode 100644 index 0000000..64dfc0d --- /dev/null +++ b/granary/arch/x86/xed-intel64.h @@ -0,0 +1,17 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_ARCH_X86_XED_INTEL64_H_ +#define GRANARY_ARCH_X86_XED_INTEL64_H_ + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wsign-conversion" +#pragma clang diagnostic ignored "-Wconversion" +#pragma clang diagnostic ignored "-Wold-style-cast" +#pragma clang diagnostic ignored "-Wdocumentation" +#pragma clang diagnostic ignored "-Wswitch-enum" +extern "C" { +#define XED_DLL +#include "../../../third_party/xed-intel64/include/xed-interface.h" +} // extern C + +#endif // GRANARY_ARCH_X86_XED_INTEL64_H_ diff --git a/granary/base/base.h b/granary/base/base.h new file mode 100644 index 0000000..e8b00cf --- /dev/null +++ b/granary/base/base.h @@ -0,0 +1,346 @@ +/* Copyright 2014 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_BASE_BASE_H_ +#define GRANARY_BASE_BASE_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +typedef long int ssize_t; + +#if defined(GRANARY_TARGET_debug) +# include +# define GRANARY_DEBUG(...) do { __VA_ARGS__ } while(false); +# define GRANARY_IF_DEBUG(...) __VA_ARGS__ +# define GRANARY_IF_DEBUG_(...) __VA_ARGS__ , +# define _GRANARY_IF_DEBUG(...) , __VA_ARGS__ +# define GRANARY_IF_DEBUG_ELSE(a, b) a +#else +# define GRANARY_DEBUG(...) +# define GRANARY_IF_DEBUG(...) +# define GRANARY_IF_DEBUG_(...) +# define _GRANARY_IF_DEBUG(...) +# define GRANARY_IF_DEBUG_ELSE(a, b) b +#endif // GRANARY_TARGET_debug + +// Serves as documentation of the key entrypoints into Granary. +#define GRANARY_ENTRYPOINT + +#define GRANARY_THREAD_LOCAL(...) __VA_ARGS__ + +#define GRANARY_EARLY_GLOBAL __attribute__((init_priority(102))) +#define GRANARY_GLOBAL __attribute__((init_priority(103))) +#define GRANARY_UNPROTECTED_GLOBAL \ + __attribute__((section(".bss.granary_unprotected"))) + +// For namespace-based `using` declarations without triggering the linter. +#define GRANARY_USING_NAMESPACE using namespace // NOLINT + +#define GRANARY_UNIQUE_SYMBOL \ + GRANARY_CAT( \ + GRANARY_CAT( \ + GRANARY_CAT(_, __LINE__), \ + GRANARY_CAT(_, __INCLUDE_LEVEL__)), \ + GRANARY_CAT(_, __COUNTER__)) + +// For use only when editing text with Eclipse CDT (my version doesn't handle +// `decltype` or `alignof` well) +#define IF_ECLIPSE_alignas(...) +#define IF_ECLIPSE_alignof(...) 16 +#ifdef GRANARY_ECLIPSE +# define alignas(...) +# define alignof(...) 16 +# define GRANARY_ENABLE_IF(...) int +# define GRANARY_IF_NOT_ECLIPSE(...) +#else +# define GRANARY_ENABLE_IF(...) __VA_ARGS__ +# define GRANARY_IF_NOT_ECLIPSE(...) __VA_ARGS__ +#endif + +# define GRANARY_IF_ASSERT(...) __VA_ARGS__ +# define GRANARY_ASSERT(...) GRANARY_ASSERT_(__VA_ARGS__) +# define GRANARY_ASSERT_(...) \ + if (!(__VA_ARGS__)) \ + granary_unreachable(#__VA_ARGS__, \ + __FILE__ ":" GRANARY_TO_STRING(__LINE__)) + +#ifdef GRANARY_ARCH_INTERNAL +# define GRANARY_ARCH_PUBLIC public +#else +# define GRANARY_ARCH_PUBLIC private +#endif + +// Marks some pointers as being internal, and convertible to void for exports. +#define GRANARY_MUTABLE mutable +#define GRANARY_POINTER(type) type +#define GRANARY_UINT32(type) type +#define GRANARY_PROTECTED public +#define GRANARY_PUBLIC public +#define GRANARY_CONST +#define GRANARY_IF_EXTERNAL(...) +#define _GRANARY_IF_EXTERNAL(...) +#define GRANARY_IF_INTERNAL(...) __VA_ARGS__ +#define _GRANARY_IF_INTERNAL(...) , __VA_ARGS__ +#define GRANARY_IF_INTERNAL_(...) __VA_ARGS__ , +#define GRANARY_EXTERNAL_DELETE + +// Name of the granary binary. +#ifndef GRANARY_NAME +# define GRANARY_NAME granary +#endif +#define GRANARY_NAME_STRING GRANARY_TO_STRING(GRANARY_NAME) + +// Static branch prediction hints. +#define GRANARY_LIKELY(x) __builtin_expect((x),1) +#define GRANARY_UNLIKELY(x) __builtin_expect((x),0) + +// Inline assembly. +#define GRANARY_INLINE_ASSEMBLY(...) __asm__ __volatile__ ( __VA_ARGS__ ) + +// Convert a sequence of symbols into a string literal. +#define GRANARY_TO_STRING__(x) #x +#define GRANARY_TO_STRING_(x) GRANARY_TO_STRING__(x) +#define GRANARY_TO_STRING(x) GRANARY_TO_STRING_(x) + +// Concatenate two symbols into one. +#define GRANARY_CAT__(x, y) x ## y +#define GRANARY_CAT_(x, y) GRANARY_CAT__(x, y) +#define GRANARY_CAT(x, y) GRANARY_CAT_(x, y) + +// Expand out into nothing. +#define GRANARY_NOTHING__ +#define GRANARY_NOTHING_ GRANARY_NOTHING__ +#define GRANARY_NOTHING GRANARY_NOTHING_ + +// Determine the number of arguments in a variadic macro argument pack. +// From: http://efesx.com/2010/07/17/variadic-macro-to-count-number-of-\ +// arguments/#comment-256 +#define GRANARY_NUM_PARAMS_(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,N,...) N +#define GRANARY_NUM_PARAMS(...) \ + GRANARY_NUM_PARAMS_(, ##__VA_ARGS__,12,11,10,9,8,7,6,5,4,3,2,1,0) + +// Splats out the arguments passed into the macro function. This assumes one +// is doing something like: `GRANARY_SPLAT((x, y))`, then what you will get +// is `x, y`. +#define GRANARY_SPLAT(params) GRANARY_PARAMS params + +// Spits back out the arguments passed into the macro function. +#define GRANARY_PARAMS(...) __VA_ARGS__ + +// Try to make sure that a function is not optimized. +#define GRANARY_DISABLE_OPTIMIZER __attribute__((used, noinline, \ + visibility ("default"))) + +// Export some function to instrumentation code. Only exported code can be +// directly invoked by instrumented code. +// +// Note: While these functions can be invoked by instrumented code, their +// code *is not* instrumented. +#define GRANARY_EXPORT_TO_INSTRUMENTATION \ + __attribute__((noinline, used, section(".text.inst_exports"))) + +// Granary function that is to be instrumented as part of a test case. +#define GRANARY_TEST_CASE \ + __attribute__((noinline, used, section(".text.test_cases"))) + +// Determine how much should be added to a value `x` in order to align `x` to +// an `align`-byte boundary. +#define GRANARY_ALIGN_FACTOR(x, align) \ + (((x) % (align)) ? ((align) - ((x) % (align))) : 0) + +// Align a value `x` to an `align`-byte boundary. +#define GRANARY_ALIGN_TO(x, align) \ + ((x) + GRANARY_ALIGN_FACTOR(x, align)) + +// Return the maximum or minimum of two values. +#define GRANARY_MIN(a, b) ((a) < (b) ? (a) : (b)) +#define GRANARY_MAX(a, b) ((a) < (b) ? (b) : (a)) + +// Disallow copying of a specific class. +#define GRANARY_DISALLOW_COPY(cls) \ + cls(const cls &) = delete; \ + cls(const cls &&) = delete + +// Disallow assigning of instances of a specific class. +#define GRANARY_DISALLOW_ASSIGN(cls) \ + void operator=(const cls &) = delete; \ + void operator=(const cls &&) = delete + +// Disallow copying and assigning of instances of a specific class. +#define GRANARY_DISALLOW_COPY_AND_ASSIGN(cls) \ + GRANARY_DISALLOW_COPY(cls); \ + GRANARY_DISALLOW_ASSIGN(cls) + +// Disallow copying of instances of a class generated by a specific +// class template. +#define GRANARY_DISALLOW_COPY_TEMPLATE(cls, params) \ + cls(const cls &) = delete; \ + cls(const cls &&) = delete + +// Disallow assigning of instances of a specific class. +#define GRANARY_DISALLOW_ASSIGN_TEMPLATE(cls, params) \ + void operator=(const cls &) = delete; \ + void operator=(const cls &&) = delete + +// Disallow copying and assigning of instances of a class generated by a +// specific class template. +#define GRANARY_DISALLOW_COPY_AND_ASSIGN_TEMPLATE(cls, params) \ + GRANARY_DISALLOW_COPY_TEMPLATE(cls, params); \ + GRANARY_DISALLOW_ASSIGN_TEMPLATE(cls, params) + + +// Mark a result / variable as being used. +#define GRANARY_UNUSED(...) (void) __VA_ARGS__ +#define GRANARY_USED(var) \ + do { \ + GRANARY_INLINE_ASSEMBLY("" :: "m"(var)); \ + GRANARY_UNUSED(var); \ + } while (0) + +#define GRANARY_COMMA() , + +// Apply a macro `pp` to each of a variable number of arguments. Separate the +// results of the macro application with `sep`. +#define GRANARY_APPLY_EACH(pp, sep, ...) \ + GRANARY_CAT(GRANARY_APPLY_EACH_, GRANARY_NUM_PARAMS(__VA_ARGS__))( \ + pp, sep, ##__VA_ARGS__) + +#define GRANARY_APPLY_EACH_1(pp, sep, a0) \ + pp(a0) + +#define GRANARY_APPLY_EACH_2(pp, sep, a0, a1) \ + pp(a0) sep() \ + pp(a1) + +#define GRANARY_APPLY_EACH_3(pp, sep, a0, a1, a2) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) + +#define GRANARY_APPLY_EACH_4(pp, sep, a0, a1, a2, a3) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) + +#define GRANARY_APPLY_EACH_5(pp, sep, a0, a1, a2, a3, a4) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) + +#define GRANARY_APPLY_EACH_6(pp, sep, a0, a1, a2, a3, a4, a5) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) + +#define GRANARY_APPLY_EACH_7(pp, sep, a0, a1, a2, a3, a4, a5, a6) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) + +#define GRANARY_APPLY_EACH_8(pp, sep, a0, a1, a2, a3, a4, a5, a6, a7) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) sep() \ + pp(a7) + +#define GRANARY_APPLY_EACH_9(pp, sep, a0, a1, a2, a3, a4, a5, a6, a7, a8) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) sep() \ + pp(a7) sep() \ + pp(a8) + +#define GRANARY_APPLY_EACH_10(pp, sep, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) sep() \ + pp(a7) sep() \ + pp(a8) sep() \ + pp(a9) + +#define GRANARY_APPLY_EACH_11(pp, sep, a0, a1, a2, a3, a4, a5,a6,a7,a8,a9,a10) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) sep() \ + pp(a7) sep() \ + pp(a8) sep() \ + pp(a9) sep() \ + pp(a10) + +#define GRANARY_APPLY_EACH_12(pp, sep, a0, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) \ + pp(a0) sep() \ + pp(a1) sep() \ + pp(a2) sep() \ + pp(a3) sep() \ + pp(a4) sep() \ + pp(a5) sep() \ + pp(a6) sep() \ + pp(a7) sep() \ + pp(a8) sep() \ + pp(a9) sep() \ + pp(a10) sep() \ + pp(a11) + +// Mark a symbol as exported. +#define GRANARY_EXPORT __attribute__((visibility("default"))) + +#if !defined(__x86_64__) && !defined(__x86_64) +# error "Granary must be compiled as a 64-bit program." +#endif + +#define GRANARY_STRACE(...) \ + if (FLAGS_strace) { __VA_ARGS__ } + +namespace granary { + +typedef const uint8_t *PC; +typedef uint8_t *CachePC; +typedef int32_t CacheOffset; +typedef void *Addr64; +typedef uint8_t *AppPC64; +typedef uint32_t Addr32; +typedef Addr32 AppPC32; + +} // namespace granary + +#include "granary/base/breakpoint.h" +#include "granary/base/interrupt.h" + +#endif // GRANARY_BASE_BASE_H_ diff --git a/granary/base/breakpoint.cc b/granary/base/breakpoint.cc new file mode 100644 index 0000000..0bb7c87 --- /dev/null +++ b/granary/base/breakpoint.cc @@ -0,0 +1,71 @@ +/* Copyright 2014 Peter Goodman, all rights reserved. */ + +#include "granary/base/base.h" + +#include +#include +#include +#include +#include + +extern "C" { + +extern intptr_t granary_crash_pc = 0; +extern intptr_t granary_crash_addr = 0; + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wmissing-noreturn" +void granary_unreachable(const char *error, const char *loc) { +#if defined(GRANARY_TARGET_debug) + granary::Uninterruptible disable_interrupts; + auto fd = open("/data/grr_crashes", O_CREAT | O_WRONLY | O_APPEND, 0666); + if (-1 != fd) { + write(fd, "Assertion failed:\n", 18); + if (error) { + write(fd, error, strlen(error)); + } + write(fd, "\n", 1); + if (loc) { + write(fd, loc, strlen(loc)); + write(fd, "\n", 1); + } + + char buf[128]; + if (granary_crash_pc) { + write(fd, buf, + static_cast(sprintf(buf, "Granary crash PC = 0x%lx\n", + granary_crash_pc))); + } + + if (granary_crash_addr) { + write(fd, buf, + static_cast(sprintf(buf, "Granary crash ADDR = 0x%lx\n", + granary_crash_addr))); + + } + +#ifdef GRANARY_TARGET_debug + write(STDERR_FILENO, buf, + static_cast(sprintf(buf, "PID to attach GDB: %d\n", getpid()))); + read(STDIN_FILENO, buf, 1); +#else + write(fd, "\n", 1); + fsync(fd); +#endif + close(fd); + } +#else + GRANARY_UNUSED(error); + GRANARY_UNUSED(loc); +#endif + exit(EXIT_FAILURE); +} +#pragma clang diagnostic pop + +void granary_curiosity(const char *cond) { + if (cond) { + GRANARY_USED(cond); + } +} + +} // extern C diff --git a/granary/base/breakpoint.h b/granary/base/breakpoint.h new file mode 100644 index 0000000..ddcee06 --- /dev/null +++ b/granary/base/breakpoint.h @@ -0,0 +1,21 @@ +/* Copyright 2014 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_BASE_BREAKPOINT_H_ +#define GRANARY_BASE_BREAKPOINT_H_ + +#include "granary/base/base.h" + +extern "C" { + +extern intptr_t granary_crash_pc; +extern intptr_t granary_crash_addr; + +// Note: Not marked as no-return so that compile won't warn us when we actually +// have some kind of "backup" case in the event of the assertion. +void granary_unreachable(const char *cond, const char *loc); + +void granary_curiosity(const char *cond=nullptr); + +} // extern C + +#endif // GRANARY_BASE_BREAKPOINT_H_ diff --git a/granary/base/compiler.h b/granary/base/compiler.h new file mode 100644 index 0000000..18c5571 --- /dev/null +++ b/granary/base/compiler.h @@ -0,0 +1,738 @@ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wmacro-redefined" +#pragma clang diagnostic ignored "-Wbuiltin-macro-redefined" + + + +// From G++-4.9 with `features.h`. +#define __DBL_MIN_EXP__ (-1021) +#define __cpp_attributes 200809 +#define __UINT_LEAST16_MAX__ 65535 +#define __ATOMIC_ACQUIRE 2 +#define __FLT_MIN__ 1.17549435082228750797e-38F +#define __GCC_IEC_559_COMPLEX 2 +#define __UINT_LEAST8_TYPE__ unsigned char +#define __flexarr [] +#define __stub_fchflags +#define __INTMAX_C(c) c ## L +#define __CHAR_BIT__ 8 +#define __UINT8_MAX__ 255 +#define __WINT_MAX__ 4294967295U +//#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min)) +#define _XOPEN_SOURCE 700 +#define __cpp_static_assert 200410 +#define __ORDER_LITTLE_ENDIAN__ 1234 +#define __SIZE_MAX__ 18446744073709551615UL +#define __stub_putmsg +#define __WCHAR_MAX__ 2147483647 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1 +#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L) +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1 +#define __GCC_ATOMIC_CHAR_LOCK_FREE 2 +#define __GCC_IEC_559 2 +#define __USE_BSD 1 +#define __FLT_EVAL_METHOD__ 0 +#define __ASMNAME2(prefix,cname) __STRING (prefix) cname +#define __unix__ 1 +#define __cpp_binary_literals 201304 +#define __stub_setlogin +#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2 +#define __SYSCALL_WORDSIZE 64 +#define __x86_64 1 +#define __cpp_variadic_templates 200704 +#define __UINT_FAST64_MAX__ 18446744073709551615UL +#define __SIG_ATOMIC_TYPE__ int +#define __DBL_MIN_10_EXP__ (-307) +#define __FINITE_MATH_ONLY__ 0 +#define __attribute_alloc_size__(params) __attribute__ ((__alloc_size__ params)) +#define __GNUC_PATCHLEVEL__ 2 +#define __UINT_FAST8_MAX__ 255 +#define __LEAF , __leaf__ +#define __LDBL_REDIR1(name,proto,alias) name proto +#define __has_include(STR) __has_include__(STR) +#define __DEC64_MAX_EXP__ 385 +#define __INT8_C(c) c +#define __UINT_LEAST64_MAX__ 18446744073709551615UL +#define __always_inline __inline __attribute__ ((__always_inline__)) +#define __SHRT_MAX__ 32767 +#define __LDBL_MAX__ 1.18973149535723176502e+4932L +#define __bos0(ptr) __builtin_object_size (ptr, 0) +#define __fortify_function __extern_always_inline __attribute_artificial__ +#define __UINT_LEAST8_MAX__ 255 +#define __GCC_ATOMIC_BOOL_LOCK_FREE 2 +#define __ptr_t void * +#define __USE_ISOCXX11 1 +#define __UINTMAX_TYPE__ long unsigned int +#define __linux 1 +#define __DEC32_EPSILON__ 1E-6DF +#define __stub_sigreturn +#define __unix 1 +#define __UINT32_MAX__ 4294967295U +#define __GXX_EXPERIMENTAL_CXX0X__ 1 +#define __LDBL_MAX_EXP__ 16384 +#define _ATFILE_SOURCE 1 +#define __WINT_MIN__ 0U +#define __linux__ 1 +#define __LDBL_REDIR_NTH(name,proto) name proto __THROW +#define __SCHAR_MAX__ 127 +#define __USING_NAMESPACE_STD(name) +#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1) +#define __KERNEL_STRICT_NAMES +#define __INT64_C(c) c ## L +#define __NTH(fct) __LEAF_ATTR fct throw () +#define __DBL_DIG__ 15 +#define __GCC_ATOMIC_POINTER_LOCK_FREE 2 +#define _POSIX_SOURCE 1 +#define __SIZEOF_INT__ 4 +#define __SIZEOF_POINTER__ 8 +#define _DEFAULT_SOURCE 1 +#define __attribute_used__ __attribute__ ((__used__)) +#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2 +#define __USER_LABEL_PREFIX__ +//#define __GLIBC__ 2 +#define __END_DECLS } +#define __CONCAT(x,y) x ## y +#define __STDC_HOSTED__ 1 +#define __LDBL_HAS_INFINITY__ 1 +#define __GNU_LIBRARY__ 6 +#define __FLT_EPSILON__ 1.19209289550781250000e-7F +#define __GXX_WEAK__ 1 +#define __LDBL_MIN__ 3.36210314311209350626e-4932L +#define __nonnull(params) __attribute__ ((__nonnull__ params)) +#define __DEC32_MAX__ 9.999999E96DF +#define __INT32_MAX__ 2147483647 +#define __SIZEOF_LONG__ 8 +#define __STDC_IEC_559__ 1 +#define __STDC_ISO_10646__ 201103L +#define __UINT16_C(c) c +#define __DECIMAL_DIG__ 21 +#define __USE_FORTIFY_LEVEL 0 +#define __gnu_linux__ 1 +#define _LARGEFILE_SOURCE 1 +#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__)) +#define __has_include_next(STR) __has_include_next__(STR) +#define __LDBL_HAS_QUIET_NAN__ 1 +#define __USE_ISOC11 1 +#define __attribute_const__ __attribute__ ((__const__)) +#define __THROW throw () +#define __GNUC__ 4 +#define __GXX_RTTI 1 +#define __MMX__ 1 +#define __FLT_HAS_DENORM__ 1 +#define __SIZEOF_LONG_DOUBLE__ 16 +#define __USE_SVID 1 +#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW +#define __BIGGEST_ALIGNMENT__ 16 +#define __USE_ISOC95 1 +#define __USE_ISOC99 1 +#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname) +#define __DBL_MAX__ double(1.79769313486231570815e+308L) +#define __cpp_raw_strings 200710 +#define __INT_FAST32_MAX__ 9223372036854775807L +#define __DBL_HAS_INFINITY__ 1 +#define __USE_LARGEFILE 1 +#define __INT64_MAX__ 9223372036854775807L +#define __USE_XOPEN 1 +#define __USE_XOPEN2K 1 +#define __DEC32_MIN_EXP__ (-94) +#define __END_NAMESPACE_C99 +#define _ISOC11_SOURCE 1 +#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b))) +#define __INT_FAST16_TYPE__ long int +#define __STRICT_ANSI__ 1 +#define __USE_POSIX199506 1 +#define _FEATURES_H 1 +#define __LDBL_HAS_DENORM__ 1 +#define __stub_getmsg +#define __stub_fattach +#define __cplusplus 201300L +#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL +#define __INT_LEAST32_MAX__ 2147483647 +#define __DEC32_MIN__ 1E-95DF +#define __DEPRECATED 1 +#define __glibc_unlikely(cond) __builtin_expect ((cond), 0) +#define __DBL_MAX_EXP__ 1024 +#define __DEC128_EPSILON__ 1E-33DL +#define __SSE2_MATH__ 1 +#define __ATOMIC_HLE_RELEASE 131072 +#define __PTRDIFF_MAX__ 9223372036854775807L +#define __amd64 1 +#define __STDC_NO_THREADS__ 1 +#define __BEGIN_NAMESPACE_STD +#define __ATOMIC_HLE_ACQUIRE 65536 +#define __GNUG__ 4 +#define __LONG_LONG_MAX__ 9223372036854775807LL +#define __SIZEOF_SIZE_T__ 8 +#define __cpp_rvalue_reference 200610 +#define __SIZEOF_WINT_T__ 4 +#define __stub_bdflush +#define __GCC_HAVE_DWARF2_CFI_ASM 1 +#define __GXX_ABI_VERSION 1002 +#define __USE_GNU 1 +#define __FLT_MIN_EXP__ (-125) +#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__)) +#define __cpp_lambdas 200907 +#define __INT_FAST64_TYPE__ long int +#define __DBL_MIN__ double(2.22507385850720138309e-308L) +#define __USE_XOPEN2KXSI 1 +#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias)) +#define __LP64__ 1 +#define __USE_UNIX98 1 +#define __LEAF_ATTR __attribute__ ((__leaf__)) +#define __DECIMAL_BID_FORMAT__ 1 +#define __DEC128_MIN__ 1E-6143DL +#define __REGISTER_PREFIX__ +#define __UINT16_MAX__ 65535 +#define __DBL_HAS_DENORM__ 1 +#define __attribute_pure__ __attribute__ ((__pure__)) +#define __USE_POSIX2 1 +#define __UINT8_TYPE__ unsigned char +#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias) +#define __NO_INLINE__ 1 +#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg))) +#define __FLT_MANT_DIG__ 24 +#define __VERSION__ "4.9.2" +#define __UINT64_C(c) c ## UL +#define _SYS_CDEFS_H 1 +#define __cpp_unicode_characters 200704 +#define _STDC_PREDEF_H 1 +#define __USE_XOPEN2K8 1 +#define __cpp_decltype_auto 201304 +#define _BSD_SOURCE 1 +#define __STRING(x) #x +#define __GCC_ATOMIC_INT_LOCK_FREE 2 +#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define __stub_gtty +#define __stub_sstk +#define __wur +#define __STDC_IEC_559_COMPLEX__ 1 +#define __INT32_C(c) c +#define __DEC64_EPSILON__ 1E-15DD +#define __ORDER_PDP_ENDIAN__ 3412 +#define __DEC128_MIN_EXP__ (-6142) +#define _ISOC95_SOURCE 1 +#define __INT_FAST32_TYPE__ long int +#define __UINT_LEAST16_TYPE__ short unsigned int +#define __USE_POSIX 1 +#define __INT16_MAX__ 32767 +#define __THROWNL throw () +#define __SIZE_TYPE__ long unsigned int +#define __UINT64_MAX__ 18446744073709551615UL +#define __va_arg_pack_len() __builtin_va_arg_pack_len () +#define __INT8_TYPE__ signed char +#define __cpp_digit_separators 201309 +#define __ELF__ 1 +#define __warnattr(msg) __attribute__((__warning__ (msg))) +#define __FLT_RADIX__ 2 +#define __INT_LEAST16_TYPE__ short int +#define __LDBL_EPSILON__ 1.08420217248550443401e-19L +#define __UINTMAX_C(c) c ## UL +#define _POSIX_C_SOURCE 200809L +#define __long_double_t long double +#define __k8 1 +#define __LDBL_REDIR(name,proto) name proto +#define __SIG_ATOMIC_MAX__ 2147483647 +#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2 +#define __SIZEOF_PTRDIFF_T__ 8 +#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg))) +#define _XOPEN_SOURCE_EXTENDED 1 +#define __restrict_arr +#define __attribute_artificial__ __attribute__ ((__artificial__)) +#define __USE_MISC 1 +#define __x86_64__ 1 +#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF +#define __INT_FAST16_MAX__ 9223372036854775807L +#define __stub_revoke +#define __UINT_FAST32_MAX__ 18446744073709551615UL +#define __UINT_LEAST64_TYPE__ long unsigned int +#define __FLT_HAS_QUIET_NAN__ 1 +#define __FLT_MAX_10_EXP__ 38 +#define __LONG_MAX__ 9223372036854775807L +#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL +#define __FLT_HAS_INFINITY__ 1 +#define __cpp_unicode_literals 200710 +#define __UINT_FAST16_TYPE__ long unsigned int +#define __cpp_attribute_deprecated 201309 +#define __DEC64_MAX__ 9.999999999999999E384DD +#define __CHAR16_TYPE__ short unsigned int +#define __PRAGMA_REDEFINE_EXTNAME 1 +#define __USING_NAMESPACE_C99(name) +#define __INT_LEAST16_MAX__ 32767 +#define __stub_lchmod +#define __DEC64_MANT_DIG__ 16 +#define __UINT_LEAST32_MAX__ 4294967295U +#define __GCC_ATOMIC_LONG_LOCK_FREE 2 +#define __INT_LEAST64_TYPE__ long int +#define __INT16_TYPE__ short int +#define __INT_LEAST8_TYPE__ signed char +#define __DEC32_MAX_EXP__ 97 +#define __INT_FAST8_MAX__ 127 +#define __PMT(args) args +#define __INTPTR_MAX__ 9223372036854775807L +#define __SSE2__ 1 +#define __EXCEPTIONS 1 +#define __WORDSIZE 64 +#define __BEGIN_DECLS extern "C" { +#define __LDBL_MANT_DIG__ 64 +#define __DBL_HAS_QUIET_NAN__ 1 +#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1) +#define __code_model_small__ 1 +#define __cpp_return_type_deduction 201304 +#define __k8__ 1 +#define __INTPTR_TYPE__ long int +#define __UINT16_TYPE__ short unsigned int +#define __WCHAR_TYPE__ int +#define __SIZEOF_FLOAT__ 4 +#define __stub_fdetach +#define __UINTPTR_MAX__ 18446744073709551615UL +#define __DEC64_MIN_EXP__ (-382) +#define __stub_chflags +#define __cpp_decltype 200707 +#define __INT_FAST64_MAX__ 9223372036854775807L +#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1 +#define __FLT_DIG__ 6 +#define __UINT_FAST64_TYPE__ long unsigned int +#define __LDBL_REDIR_DECL(name) +#define __INT_MAX__ 2147483647 +#define __amd64__ 1 +#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) +#define __USE_LARGEFILE64 1 +#define __INT64_TYPE__ long int +#define __FLT_MAX_EXP__ 128 +#define __ORDER_BIG_ENDIAN__ 4321 +#define __DBL_MANT_DIG__ 53 +#define __INT_LEAST64_MAX__ 9223372036854775807L +//#define __GLIBC_MINOR__ 19 +#define __DEC64_MIN__ 1E-383DD +#define __WINT_TYPE__ unsigned int +#define __UINT_LEAST32_TYPE__ unsigned int +#define __SIZEOF_SHORT__ 2 +#define __SSE__ 1 +#define __LDBL_MIN_EXP__ (-16381) +#define __REDIRECT_NTHNL(name,proto,alias) name proto __THROWNL __asm__ (__ASMNAME (#alias)) +#define __INT_LEAST8_MAX__ 127 +#define __extern_inline extern __inline __attribute__ ((__gnu_inline__)) +#define __USE_POSIX199309 1 +#define __SSP__ 1 +#define __SIZEOF_INT128__ 16 +#define __LDBL_MAX_10_EXP__ 4932 +#define __ATOMIC_RELAXED 0 +#define __DBL_EPSILON__ double(2.22044604925031308085e-16L) +#define __stub_stty +#define _SVID_SOURCE 1 +#define _LP64 1 +#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias) +#define __UINT8_C(c) c +#define __INT_LEAST32_TYPE__ int +#define __SIZEOF_WCHAR_T__ 4 +#define __UINT64_TYPE__ long unsigned int +#define _ISOC99_SOURCE 1 +#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias)) +#define __END_NAMESPACE_STD +#define _LARGEFILE64_SOURCE 1 +#define __INT_FAST8_TYPE__ signed char +#define __GNUC_STDC_INLINE__ 1 +#define __WORDSIZE_TIME64_COMPAT32 1 +#define __DBL_DECIMAL_DIG__ 17 +#define __FXSR__ 1 +#define __DEC_EVAL_METHOD__ 2 +#define __cpp_runtime_arrays 201304 +#define __USE_XOPEN2K8XSI 1 +#define __UINT32_C(c) c ## U +#define __INTMAX_MAX__ 9223372036854775807L +#define __cpp_alias_templates 200704 +#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F +#define __BEGIN_NAMESPACE_C99 +#define __INT8_MAX__ 127 +#define __UINT_FAST32_TYPE__ long unsigned int +#define __CHAR32_TYPE__ unsigned int +#define __FLT_MAX__ 3.40282346638528859812e+38F +#define __cpp_constexpr 200704 +#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) +#define __INT32_TYPE__ int +#define __SIZEOF_DOUBLE__ 8 +#define __INTMAX_TYPE__ long int +#define __DEC128_MAX_EXP__ 6145 +#define __va_arg_pack() __builtin_va_arg_pack () +#define __ATOMIC_CONSUME 1 +#define __GNUC_MINOR__ 9 +#define __UINTMAX_MAX__ 18446744073709551615UL +#define __DEC32_MANT_DIG__ 7 +#define __DBL_MAX_10_EXP__ 308 +#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L +#define __USE_XOPEN_EXTENDED 1 +#define __INT16_C(c) c +#define __cpp_generic_lambdas 201304 +#define __STDC__ 1 +#define __attribute_malloc__ __attribute__ ((__malloc__)) +#define __PTRDIFF_TYPE__ long int +#define __attribute_noinline__ __attribute__ ((__noinline__)) +#define __ATOMIC_SEQ_CST 5 +#define __UINT32_TYPE__ unsigned int +#define __UINTPTR_TYPE__ long unsigned int +#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD +#define __DEC128_MANT_DIG__ 34 +#define __LDBL_MIN_10_EXP__ (-4931) +#define __attribute_deprecated__ __attribute__ ((__deprecated__)) +#define __SSE_MATH__ 1 +#define __SIZEOF_LONG_LONG__ 8 +#define __cpp_user_defined_literals 200809 +#define __USE_ATFILE 1 +#define __GCC_ATOMIC_LLONG_LOCK_FREE 2 +#define __LDBL_DIG__ 18 +#define __FLT_DECIMAL_DIG__ 9 +#define __UINT_FAST16_MAX__ 18446744073709551615UL +#define __FLT_MIN_10_EXP__ (-37) +#define __GCC_ATOMIC_SHORT_LOCK_FREE 2 +#define __glibc_likely(cond) __builtin_expect ((cond), 1) +#define __UINT_FAST8_TYPE__ unsigned char +#define _GNU_SOURCE 1 +#define __P(args) args +#define __cpp_init_captures 201304 +#define __ATOMIC_ACQ_REL 4 +#define __ATOMIC_RELEASE 3 + + +// From clang++-3.5 +#define _GNU_SOURCE 1 +#define _LP64 1 +#define __ATOMIC_ACQUIRE 2 +#define __ATOMIC_ACQ_REL 4 +#define __ATOMIC_CONSUME 1 +#define __ATOMIC_RELAXED 0 +#define __ATOMIC_RELEASE 3 +#define __ATOMIC_SEQ_CST 5 +#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define __CHAR16_TYPE__ unsigned short +#define __CHAR32_TYPE__ unsigned int +#define __CHAR_BIT__ 8 +#define __CONSTANT_CFSTRINGS__ 1 +#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 +#define __DBL_DIG__ 15 +#define __DBL_EPSILON__ 2.2204460492503131e-16 +#define __DBL_HAS_DENORM__ 1 +#define __DBL_HAS_INFINITY__ 1 +#define __DBL_HAS_QUIET_NAN__ 1 +#define __DBL_MANT_DIG__ 53 +#define __DBL_MAX_10_EXP__ 308 +#define __DBL_MAX_EXP__ 1024 +#define __DBL_MAX__ 1.7976931348623157e+308 +#define __DBL_MIN_10_EXP__ (-307) +#define __DBL_MIN_EXP__ (-1021) +#define __DBL_MIN__ 2.2250738585072014e-308 +#define __DECIMAL_DIG__ 21 +#define __DEPRECATED 1 +#define __ELF__ 1 +#define __EXCEPTIONS 1 +#define __FINITE_MATH_ONLY__ 0 +#define __FLT_DENORM_MIN__ 1.40129846e-45F +#define __FLT_DIG__ 6 +#define __FLT_EPSILON__ 1.19209290e-7F +#define __FLT_EVAL_METHOD__ 0 +#define __FLT_HAS_DENORM__ 1 +#define __FLT_HAS_INFINITY__ 1 +#define __FLT_HAS_QUIET_NAN__ 1 +#define __FLT_MANT_DIG__ 24 +#define __FLT_MAX_10_EXP__ 38 +#define __FLT_MAX_EXP__ 128 +#define __FLT_MAX__ 3.40282347e+38F +#define __FLT_MIN_10_EXP__ (-37) +#define __FLT_MIN_EXP__ (-125) +#define __FLT_MIN__ 1.17549435e-38F +#define __FLT_RADIX__ 2 +#define __GCC_ATOMIC_BOOL_LOCK_FREE 2 +#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2 +#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2 +#define __GCC_ATOMIC_CHAR_LOCK_FREE 2 +#define __GCC_ATOMIC_INT_LOCK_FREE 2 +#define __GCC_ATOMIC_LLONG_LOCK_FREE 2 +#define __GCC_ATOMIC_LONG_LOCK_FREE 2 +#define __GCC_ATOMIC_POINTER_LOCK_FREE 2 +#define __GCC_ATOMIC_SHORT_LOCK_FREE 2 +#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1 +#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1 +#define __GNUC_GNU_INLINE__ 1 +#define __GNUC_MINOR__ 2 +#define __GNUC_PATCHLEVEL__ 1 +#define __GNUC__ 4 +#define __GNUG__ 4 +#define __GXX_ABI_VERSION 1002 +#define __GXX_EXPERIMENTAL_CXX0X__ 1 +#define __GXX_RTTI 1 +#define __GXX_WEAK__ 1 +#define __INT16_C_SUFFIX__ +#define __INT16_FMTd__ "hd" +#define __INT16_FMTi__ "hi" +#define __INT16_MAX__ 32767 +#define __INT16_TYPE__ short +#define __INT32_C_SUFFIX__ +#define __INT32_FMTd__ "d" +#define __INT32_FMTi__ "i" +#define __INT32_MAX__ 2147483647 +#define __INT32_TYPE__ int +#define __INT64_C_SUFFIX__ L +#define __INT64_FMTd__ "ld" +#define __INT64_FMTi__ "li" +#define __INT64_MAX__ 9223372036854775807L +#define __INT64_TYPE__ long int +#define __INT8_C_SUFFIX__ +#define __INT8_FMTd__ "hhd" +#define __INT8_FMTi__ "hhi" +#define __INT8_MAX__ 127 +#define __INT8_TYPE__ signed char +#define __INTMAX_C_SUFFIX__ L +#define __INTMAX_FMTd__ "ld" +#define __INTMAX_FMTi__ "li" +#define __INTMAX_MAX__ 9223372036854775807L +#define __INTMAX_TYPE__ long int +#define __INTMAX_WIDTH__ 64 +#define __INTPTR_FMTd__ "ld" +#define __INTPTR_FMTi__ "li" +#define __INTPTR_MAX__ 9223372036854775807L +#define __INTPTR_TYPE__ long int +#define __INTPTR_WIDTH__ 64 +#define __INT_FAST16_FMTd__ "hd" +#define __INT_FAST16_FMTi__ "hi" +#define __INT_FAST16_MAX__ 32767 +#define __INT_FAST16_TYPE__ short +#define __INT_FAST32_FMTd__ "d" +#define __INT_FAST32_FMTi__ "i" +#define __INT_FAST32_MAX__ 2147483647 +#define __INT_FAST32_TYPE__ int +#define __INT_FAST64_FMTd__ "ld" +#define __INT_FAST64_FMTi__ "li" +#define __INT_FAST64_MAX__ 9223372036854775807L +#define __INT_FAST64_TYPE__ long int +#define __INT_FAST8_FMTd__ "hhd" +#define __INT_FAST8_FMTi__ "hhi" +#define __INT_FAST8_MAX__ 127 +#define __INT_FAST8_TYPE__ signed char +#define __INT_LEAST16_FMTd__ "hd" +#define __INT_LEAST16_FMTi__ "hi" +#define __INT_LEAST16_MAX__ 32767 +#define __INT_LEAST16_TYPE__ short +#define __INT_LEAST32_FMTd__ "d" +#define __INT_LEAST32_FMTi__ "i" +#define __INT_LEAST32_MAX__ 2147483647 +#define __INT_LEAST32_TYPE__ int +#define __INT_LEAST64_FMTd__ "ld" +#define __INT_LEAST64_FMTi__ "li" +#define __INT_LEAST64_MAX__ 9223372036854775807L +#define __INT_LEAST64_TYPE__ long int +#define __INT_LEAST8_FMTd__ "hhd" +#define __INT_LEAST8_FMTi__ "hhi" +#define __INT_LEAST8_MAX__ 127 +#define __INT_LEAST8_TYPE__ signed char +#define __INT_MAX__ 2147483647 +#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L +#define __LDBL_DIG__ 18 +#define __LDBL_EPSILON__ 1.08420217248550443401e-19L +#define __LDBL_HAS_DENORM__ 1 +#define __LDBL_HAS_INFINITY__ 1 +#define __LDBL_HAS_QUIET_NAN__ 1 +#define __LDBL_MANT_DIG__ 64 +#define __LDBL_MAX_10_EXP__ 4932 +#define __LDBL_MAX_EXP__ 16384 +#define __LDBL_MAX__ 1.18973149535723176502e+4932L +#define __LDBL_MIN_10_EXP__ (-4931) +#define __LDBL_MIN_EXP__ (-16381) +#define __LDBL_MIN__ 3.36210314311209350626e-4932L +#define __LITTLE_ENDIAN__ 1 +#define __LONG_LONG_MAX__ 9223372036854775807LL +#define __LONG_MAX__ 9223372036854775807L +#define __LP64__ 1 +#define __MMX__ 1 +#define __NO_INLINE__ 1 +#define __NO_MATH_INLINES 1 +#define __ORDER_BIG_ENDIAN__ 4321 +#define __ORDER_LITTLE_ENDIAN__ 1234 +#define __ORDER_PDP_ENDIAN__ 3412 +#define __POINTER_WIDTH__ 64 +#define __PRAGMA_REDEFINE_EXTNAME 1 +#define __PTRDIFF_FMTd__ "ld" +#define __PTRDIFF_FMTi__ "li" +#define __PTRDIFF_MAX__ 9223372036854775807L +#define __PTRDIFF_TYPE__ long int +#define __PTRDIFF_WIDTH__ 64 +#define __REGISTER_PREFIX__ +#define __SCHAR_MAX__ 127 +#define __SHRT_MAX__ 32767 +#define __SIG_ATOMIC_MAX__ 2147483647 +#define __SIG_ATOMIC_WIDTH__ 32 +#define __SIZEOF_DOUBLE__ 8 +#define __SIZEOF_FLOAT__ 4 +#define __SIZEOF_INT128__ 16 +#define __SIZEOF_INT__ 4 +#define __SIZEOF_LONG_DOUBLE__ 16 +#define __SIZEOF_LONG_LONG__ 8 +#define __SIZEOF_LONG__ 8 +#define __SIZEOF_POINTER__ 8 +#define __SIZEOF_PTRDIFF_T__ 8 +#define __SIZEOF_SHORT__ 2 +#define __SIZEOF_SIZE_T__ 8 +#define __SIZEOF_WCHAR_T__ 4 +#define __SIZEOF_WINT_T__ 4 +#define __SIZE_FMTX__ "lX" +#define __SIZE_FMTo__ "lo" +#define __SIZE_FMTu__ "lu" +#define __SIZE_FMTx__ "lx" +#define __SIZE_MAX__ 18446744073709551615UL +#define __SIZE_TYPE__ long unsigned int +#define __SIZE_WIDTH__ 64 +#define __SSE2_MATH__ 1 +#define __SSE2__ 1 +#define __SSE_MATH__ 1 +#define __SSE__ 1 +#define __STDC_HOSTED__ 1 +#define __STDC_UTF_16__ 1 +#define __STDC_UTF_32__ 1 +#define __STDC__ 1 +#define __STRICT_ANSI__ 1 +#define __UINT16_C_SUFFIX__ +#define __UINT16_FMTX__ "hX" +#define __UINT16_FMTo__ "ho" +#define __UINT16_FMTu__ "hu" +#define __UINT16_FMTx__ "hx" +#define __UINT16_MAX__ 65535 +#define __UINT16_TYPE__ unsigned short +#define __UINT32_C_SUFFIX__ U +#define __UINT32_FMTX__ "X" +#define __UINT32_FMTo__ "o" +#define __UINT32_FMTu__ "u" +#define __UINT32_FMTx__ "x" +#define __UINT32_MAX__ 4294967295U +#define __UINT32_TYPE__ unsigned int +#define __UINT64_C_SUFFIX__ UL +#define __UINT64_FMTX__ "lX" +#define __UINT64_FMTo__ "lo" +#define __UINT64_FMTu__ "lu" +#define __UINT64_FMTx__ "lx" +#define __UINT64_MAX__ 18446744073709551615UL +#define __UINT64_TYPE__ long unsigned int +#define __UINT8_C_SUFFIX__ +#define __UINT8_FMTX__ "hhX" +#define __UINT8_FMTo__ "hho" +#define __UINT8_FMTu__ "hhu" +#define __UINT8_FMTx__ "hhx" +#define __UINT8_MAX__ 255 +#define __UINT8_TYPE__ unsigned char +#define __UINTMAX_C_SUFFIX__ UL +#define __UINTMAX_FMTX__ "lX" +#define __UINTMAX_FMTo__ "lo" +#define __UINTMAX_FMTu__ "lu" +#define __UINTMAX_FMTx__ "lx" +#define __UINTMAX_MAX__ 18446744073709551615UL +#define __UINTMAX_TYPE__ long unsigned int +#define __UINTMAX_WIDTH__ 64 +#define __UINTPTR_FMTX__ "lX" +#define __UINTPTR_FMTo__ "lo" +#define __UINTPTR_FMTu__ "lu" +#define __UINTPTR_FMTx__ "lx" +#define __UINTPTR_MAX__ 18446744073709551615UL +#define __UINTPTR_TYPE__ long unsigned int +#define __UINTPTR_WIDTH__ 64 +#define __UINT_FAST16_FMTX__ "hX" +#define __UINT_FAST16_FMTo__ "ho" +#define __UINT_FAST16_FMTu__ "hu" +#define __UINT_FAST16_FMTx__ "hx" +#define __UINT_FAST16_MAX__ 65535 +#define __UINT_FAST16_TYPE__ unsigned short +#define __UINT_FAST32_FMTX__ "X" +#define __UINT_FAST32_FMTo__ "o" +#define __UINT_FAST32_FMTu__ "u" +#define __UINT_FAST32_FMTx__ "x" +#define __UINT_FAST32_MAX__ 4294967295U +#define __UINT_FAST32_TYPE__ unsigned int +#define __UINT_FAST64_FMTX__ "lX" +#define __UINT_FAST64_FMTo__ "lo" +#define __UINT_FAST64_FMTu__ "lu" +#define __UINT_FAST64_FMTx__ "lx" +#define __UINT_FAST64_MAX__ 18446744073709551615UL +#define __UINT_FAST64_TYPE__ long unsigned int +#define __UINT_FAST8_FMTX__ "hhX" +#define __UINT_FAST8_FMTo__ "hho" +#define __UINT_FAST8_FMTu__ "hhu" +#define __UINT_FAST8_FMTx__ "hhx" +#define __UINT_FAST8_MAX__ 255 +#define __UINT_FAST8_TYPE__ unsigned char +#define __UINT_LEAST16_FMTX__ "hX" +#define __UINT_LEAST16_FMTo__ "ho" +#define __UINT_LEAST16_FMTu__ "hu" +#define __UINT_LEAST16_FMTx__ "hx" +#define __UINT_LEAST16_MAX__ 65535 +#define __UINT_LEAST16_TYPE__ unsigned short +#define __UINT_LEAST32_FMTX__ "X" +#define __UINT_LEAST32_FMTo__ "o" +#define __UINT_LEAST32_FMTu__ "u" +#define __UINT_LEAST32_FMTx__ "x" +#define __UINT_LEAST32_MAX__ 4294967295U +#define __UINT_LEAST32_TYPE__ unsigned int +#define __UINT_LEAST64_FMTX__ "lX" +#define __UINT_LEAST64_FMTo__ "lo" +#define __UINT_LEAST64_FMTu__ "lu" +#define __UINT_LEAST64_FMTx__ "lx" +#define __UINT_LEAST64_MAX__ 18446744073709551615UL +#define __UINT_LEAST64_TYPE__ long unsigned int +#define __UINT_LEAST8_FMTX__ "hhX" +#define __UINT_LEAST8_FMTo__ "hho" +#define __UINT_LEAST8_FMTu__ "hhu" +#define __UINT_LEAST8_FMTx__ "hhx" +#define __UINT_LEAST8_MAX__ 255 +#define __UINT_LEAST8_TYPE__ unsigned char +#define __USER_LABEL_PREFIX__ +#define __VERSION__ "4.2.1 Compatible Ubuntu Clang 3.5.0 (tags/RELEASE_350/final)" +#define __WCHAR_MAX__ 2147483647 +#define __WCHAR_TYPE__ int +#define __WCHAR_WIDTH__ 32 +#define __WINT_TYPE__ unsigned int +#define __WINT_UNSIGNED__ 1 +#define __WINT_WIDTH__ 32 +#define __amd64 1 +#define __amd64__ 1 +#define __clang__ 1 +#define __clang_major__ 3 +#define __clang_minor__ 5 +#define __clang_patchlevel__ 0 +#define __clang_version__ "3.5.0 (tags/RELEASE_350/final)" +#define __cplusplus 201402L +#define __cpp_aggregate_nsdmi 201304 +#define __cpp_attributes 200809 +#define __cpp_binary_literals 201304 +#define __cpp_constexpr 201304 +#define __cpp_decltype 200707 +#define __cpp_decltype_auto 201304 +#define __cpp_generic_lambdas 201304 +#define __cpp_init_captures 201304 +#define __cpp_lambdas 200907 +#define __cpp_raw_strings 200710 +#define __cpp_return_type_deduction 201304 +#define __cpp_rvalue_references 200610 +#define __cpp_static_assert 200410 +#define __cpp_unicode_characters 200704 +#define __cpp_unicode_literals 200710 +#define __cpp_user_defined_literals 200809 +#define __cpp_variable_templates 201304 +#define __cpp_variadic_templates 200704 +#define __gnu_linux__ 1 +#define __k8 1 +#define __k8__ 1 +#define __linux 1 +#define __linux__ 1 +#define __llvm__ 1 +#define __private_extern__ extern +#define __tune_k8__ 1 +#define __unix 1 +#define __unix__ 1 +#define __x86_64 1 +#define __x86_64__ 1 + + +#pragma clang diagnostic pop diff --git a/granary/base/interrupt.cc b/granary/base/interrupt.cc new file mode 100644 index 0000000..6e839eb --- /dev/null +++ b/granary/base/interrupt.cc @@ -0,0 +1,104 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/base/base.h" + +#include +#include + +#include + +namespace granary { +namespace { + +static detail::InterruptState *gInterruptState = nullptr; + +} // namespace +namespace detail { + +InterruptState::InterruptState(bool is_interruptible_, bool is_ignorable_) + : is_interruptible(is_interruptible_), + is_ignorable(is_ignorable_), + is_done(false), + pending_signal(0), + prev_state(gInterruptState) { + + // Down-propagate if we've entered an interruptible region, but only deliver + // the signal at the end. + if (is_interruptible && prev_state && prev_state->pending_signal) { + pending_signal = prev_state->pending_signal; + prev_state->pending_signal = 0; + } + + gInterruptState = this; +} + +InterruptState::~InterruptState(void) { + + // We've got a pending signal that we haven't handled yet. Either handle it + // or up-propagate it. + if (pending_signal && !is_done) { + if (!is_interruptible) { + if (prev_state && !prev_state->pending_signal) { + prev_state->pending_signal = pending_signal; + } + pending_signal = 0; + is_done = true; + } else { + is_done = true; + raise(pending_signal); + + //GRANARY_ASSERT(false && "Unable to deliver pending signal (2)."); + } + } + + gInterruptState = prev_state; +} + +} // namespace detail + +bool IsInterruptible(void) { + return !gInterruptState || gInterruptState->is_interruptible; +} + +void QueueInterrupt(int signal) { + GRANARY_ASSERT(gInterruptState && "Can't queue interrupt."); + if (!gInterruptState->is_ignorable) { + gInterruptState->pending_signal = signal; + } +} + +bool HasPendingInterrupt(void) { + for (auto state = gInterruptState; state; state = state->prev_state) { + if (state->pending_signal) { + return true; + } + } + return false; +} + +void MutePendingInterrupt(void) { + for (auto state = gInterruptState; state; state = state->prev_state) { + if (state->pending_signal) { + state->pending_signal = 0; + } + } +} + +void NonMaskableInterrupt(void) { + auto sig = SIGUSR1; + + // If there's a pending signal, then deliver it; otherwise, deliver the NMI. + for (auto state = gInterruptState; state; state = state->prev_state) { + if (state->pending_signal) { + sig = state->pending_signal; + state->pending_signal = 0; + gInterruptState->is_interruptible = true; + } + } + raise(sig); + + GRANARY_ASSERT(false && "Unable to raise non-maskable interrupt."); + __builtin_unreachable(); +} + +} // namespace granary diff --git a/granary/base/interrupt.h b/granary/base/interrupt.h new file mode 100644 index 0000000..86f42e5 --- /dev/null +++ b/granary/base/interrupt.h @@ -0,0 +1,67 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_BASE_INTERRUPT_H_ +#define GRANARY_BASE_INTERRUPT_H_ + +namespace granary { +namespace detail { + +class InterruptState { + public: + explicit InterruptState(bool is_interruptible_, bool is_ignorable_); + ~InterruptState(void); + + bool is_interruptible; + bool is_ignorable; + bool is_done; + int pending_signal; + InterruptState *prev_state; + + private: + InterruptState(void) = delete; + + GRANARY_DISALLOW_COPY_AND_ASSIGN(InterruptState); +}; + +} // namespace + +bool IsInterruptible(void); +void QueueInterrupt(int signal); +bool HasPendingInterrupt(void); +void MutePendingInterrupt(void); +[[noreturn]] void NonMaskableInterrupt(void); + +class Interruptible : public detail::InterruptState { + public: + inline Interruptible(void) + : detail::InterruptState(true, false) {} + + ~Interruptible(void) = default; + + private: + GRANARY_DISALLOW_COPY_AND_ASSIGN(Interruptible); +}; + +class Uninterruptible : public detail::InterruptState { + public: + inline Uninterruptible(void) + : detail::InterruptState(false, false) {} + + ~Uninterruptible(void) = default; + + GRANARY_DISALLOW_COPY_AND_ASSIGN(Uninterruptible); +}; + +class Ignorable : public detail::InterruptState { + public: + inline Ignorable(void) + : detail::InterruptState(false, true) {} + + ~Ignorable(void) = default; + + private: + GRANARY_DISALLOW_COPY_AND_ASSIGN(Ignorable); +}; +} // namespace granary + +#endif // GRANARY_BASE_INTERRUPT_H_ diff --git a/granary/code/block.cc b/granary/code/block.cc new file mode 100644 index 0000000..f5b5697 --- /dev/null +++ b/granary/code/block.cc @@ -0,0 +1,124 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include + +#include "granary/code/cache.h" +#include "granary/code/block.h" + +DEFINE_int32(max_instructions_per_block, 32, + "Maximum number of instructions per basic block."); + +namespace granary { + +// Initialize a block. +Block::Block(void) + : start_app_pc(0), + end_app_pc(0), + num_app_instructions(0), + has_syscall(false), + has_error(false), + app_instructions(), + cache_instructions() {} + +AppPC32 Block::StartPC(void) const { + return start_app_pc; +} + +AppPC32 Block::EndPC(void) const { + return end_app_pc; +} + +size_t Block::NumInstructions(void) const { + return num_app_instructions; +} + +size_t Block::NumBytes(void) const { + return static_cast(end_app_pc - start_app_pc); +} + +// Return the first instruction of the block. +Instruction *Block::FirstInstruction(void) { + return &(app_instructions[0]); +} + +Instruction *Block::LastInstruction(void) { + return &(app_instructions[num_app_instructions - 1]); +} + +// Iterate over application instructions. +InstructionIterator Block::begin(void) { + return InstructionIterator(FirstInstruction()); +} + +InstructionIterator Block::end(void) { + return InstructionIterator(LastInstruction() + 1); +} + +ReverseInstructionIterator Block::rbegin(void) { + return ReverseInstructionIterator(LastInstruction()); +} + +ReverseInstructionIterator Block::rend(void) { + return ReverseInstructionIterator(FirstInstruction() - 1); +} + +namespace { + +// Returns true if `instr` should mark the end of a block. +static bool AtBlockEnd(const Instruction &instr) { + return instr.IsBranch() || instr.IsJump() || + instr.IsFunctionCall() || instr.IsFunctionReturn() || + instr.IsSystemCall() || instr.IsSystemReturn() || + instr.IsInterruptCall() || instr.IsInterruptReturn() || + instr.IsSerializing() || instr.IsUndefined(); +} + +// Read the bytes of an instruction. +static size_t ReadInstructionBytes( + const std::function &try_read_byte, + AppPC32 pc32, uint8_t *bytes) { + for (auto i = 0U; i < arch::kMaxNumInstructionBytes; ++i) { + if (!try_read_byte(pc32 + i, bytes[i])) { + return i; + } + } + return arch::kMaxNumInstructionBytes; +} + +// Decode an instruction. +static Instruction DecodeInstruction(Block *block, AppPC32 pc32, uint8_t *bytes, + size_t num_bytes) { + Instruction instr; + auto &ainstr(instr.instruction); + if (!ainstr.TryDecode(bytes, num_bytes, arch::ISA::x86)) { + block->has_error = true; + } + ainstr.SetStartPC(pc32); + return instr; +} + + +} // namespace + +// Decodes and returns the block starting at `start_app_pc`. +void Block::DoDecode( + AppPC32 pc32, + const std::function &try_read_byte) { + start_app_pc = pc32; + end_app_pc = pc32; + + app_instructions.reserve(FLAGS_max_instructions_per_block); + + uint8_t instr_bytes[arch::kMaxNumInstructionBytes] = {0}; + for (int i = 0; i < FLAGS_max_instructions_per_block; ++i) { + auto num_bytes = ReadInstructionBytes(try_read_byte, pc32, instr_bytes); + auto instr = DecodeInstruction(this, pc32, instr_bytes, num_bytes); + end_app_pc += instr.NumBytes(); + pc32 = end_app_pc; + num_app_instructions += 1; + app_instructions.push_back(instr); + if (AtBlockEnd(instr)) break; + } +} + +} // namespace granary diff --git a/granary/code/block.h b/granary/code/block.h new file mode 100644 index 0000000..132e8df --- /dev/null +++ b/granary/code/block.h @@ -0,0 +1,84 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_CODE_BLOCK_H_ +#define GRANARY_CODE_BLOCK_H_ + +#include "granary/code/index.h" +#include "granary/code/instruction.h" + +#include +#include + +namespace granary { + +// Represents a decoded basic block of application code that can be +// instrumented. +class Block final { + public: + Block(void); + + // Beginning program counter of this instruction. + AppPC32 StartPC(void) const; + + // Program counter of the next logical instruction after this instruction. + AppPC32 EndPC(void) const; + + // Size of this instruction in bytes. + size_t NumBytes(void) const; + + // Number of instructions in this block. + size_t NumInstructions(void) const; + + // Return the first/last instruction of the block. + Instruction *FirstInstruction(void); + Instruction *LastInstruction(void); + + InstructionIterator begin(void); + InstructionIterator end(void); + + ReverseInstructionIterator rbegin(void); + ReverseInstructionIterator rend(void); + + // Decodes and returns the block starting at `start_pc`. + template + void Decode(AppPC32 pc32, TryRead try_read_byte) { + DoDecode(pc32, try_read_byte); + } + + // Encodes the the block and returns a pointer to the location in the code + // cache at which the block was encoded. + // + // Note: This function is NOT thread safe. `EncodedSize` and `Encode` should + // be performed in a transaction. + void Encode(index::Value &val); + + AppPC32 start_app_pc; + AppPC32 end_app_pc; // After the CFI. + + // Number of application instructions in this block. + unsigned num_app_instructions; + + // Does this block have a system call? + bool has_syscall; + + // Was there an error (decoding/emulating/encoding)? + bool has_error; + + // Actual instructions in this block. + std::vector app_instructions; + + // Queue of instructions that will be encoded. + arch::InstructionStack cache_instructions; + + private: + // Decodes and returns the block starting at `start_pc`. + void DoDecode( + AppPC32 pc32, + const std::function &try_read_byte); + + GRANARY_DISALLOW_COPY_AND_ASSIGN(Block); +}; + +} // namespace granary + +#endif // GRANARY_CODE_BLOCK_H_ diff --git a/granary/code/branch_tracer.cc b/granary/code/branch_tracer.cc new file mode 100644 index 0000000..31866e9 --- /dev/null +++ b/granary/code/branch_tracer.cc @@ -0,0 +1,51 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/branch_tracer.h" +#include "granary/code/index.h" +#include "granary/code/instrument.h" + +#include "granary/os/process.h" + +#include + +#include + +DEFINE_bool(branch_tracer, false, "Enable branch tracing? If so, the branch " + "trace is printed to stderr."); + +namespace granary { +namespace code { + +extern "C" { +void TraceBranchImpl( + Addr32 block_pc_of_last_branch, + Addr32 block_pc_of_branch, + Addr32 target_block_pc_of_branch) { + os::gProcess->SaveFPUState(); + std::cerr << std::hex + << block_pc_of_last_branch << " -> " + << block_pc_of_branch << " -> " + << target_block_pc_of_branch << std::endl; + os::gProcess->RestoreFPUState(); +} + +// Defined in `tracer.S`. Saves some machine state +extern void TraceBranch(void); + +} // extern C + +void InitBranchTracer(void) { + if (!FLAGS_branch_tracer) { + return; + } + code::AddInstrumentationFunction( + code::InstrumentationPoint::kInstrumentMultiWayBranch, + TraceBranch); +} + +void ExitBranchTracer(void) { + +} + +} // namespace code +} // namespace granary diff --git a/granary/code/branch_tracer.h b/granary/code/branch_tracer.h new file mode 100644 index 0000000..7204b3b --- /dev/null +++ b/granary/code/branch_tracer.h @@ -0,0 +1,15 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef CLIENT_TRACER_H_ +#define CLIENT_TRACER_H_ + +namespace granary { +namespace code { + +void InitBranchTracer(void); +void ExitBranchTracer(void); + +} // namespace code +} // namespace granary + +#endif // CLIENT_TRACER_H_ diff --git a/granary/code/cache.cc b/granary/code/cache.cc new file mode 100644 index 0000000..a32310d --- /dev/null +++ b/granary/code/cache.cc @@ -0,0 +1,232 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/cache.h" +#include "granary/code/index.h" + +#include "granary/arch/instrument.h" + +#include "granary/os/page.h" + +#include + +#include +#include +#include + +#include +#include +#include + +DECLARE_bool(persist); +DECLARE_string(persist_dir); + +namespace granary { +namespace { +enum : size_t { + k250MiB = 1ULL << 28ULL +}; +} // namespace +namespace cache { +namespace { +enum : unsigned { + kProbesPerEntry = 4, + kNumEntries = 2048, + kNumCacheSlots = kNumEntries + kProbesPerEntry, +}; + +struct CacheEntry { + AppPC32 app_pc; + uint32_t cache_pc; +}; + +extern "C" { + +CacheEntry gInlineCache[kNumCacheSlots]; + +void *gCacheAddr = nullptr; + +} // extern C + +static uint8_t gNextInlineCacheEntry[kNumEntries] = {0}; + +// Beginning of the memory mapping for the code cache. +static void *gBegin = nullptr; +static void *gBeginSync = nullptr; +static void *gEnd = nullptr; + +// The beginning of the code cache, as a `CachePC`. +static CachePC gBeginSyncPC = nullptr; + +// The next code cache location that can be allocated. +static CachePC gNextBlockPC = nullptr; + +// Path to the persisted cache file. +static char gCachePath[256] = {'\0'}; + +// File descriptor for the code cache. +static int gFd = -1; + +// Flags for `mmap`. +static int gMMapFlags = MAP_FIXED | MAP_POPULATE | MAP_SHARED | MAP_32BIT; + +// Size (in bytes) of the code cache. +static size_t gCacheSize = 0; + +// Should the cache be synchronized with the file system? +static bool gSyncCache = false; + +// Is the inline cache empty? This lets us avoid redundant inline cache flushes. +static bool kCacheIsEmpty = true; + +// Returns the size of the existing cache. +static size_t ExistingCacheSize(void) { + if (!FLAGS_persist) return 0; + struct stat64 info; + fstat64(gFd, &info); + return static_cast(info.st_size); +} + +// Adds a new page to the end of the code cache. +static void ResizeCache(void) { + off64_t offset = 0; + if (FLAGS_persist) { + GRANARY_IF_ASSERT( errno = 0; ) + ftruncate64(gFd, static_cast(gCacheSize + os::kPageSize)); + GRANARY_ASSERT(!errno && "Unable to resize code cache."); + + offset = static_cast(gCacheSize); + } + + GRANARY_IF_ASSERT( errno = 0; ) + mmap64(gEnd, os::kPageSize, PROT_READ | PROT_WRITE | PROT_EXEC, gMMapFlags, + gFd, offset); + GRANARY_ASSERT(!errno && "Unable to map new end of code cache."); + + gCacheSize += os::kPageSize; + gEnd = gBeginSyncPC + gCacheSize; +} + +static void InitInstrumentation(void) { + GRANARY_IF_ASSERT( errno = 0; ) + mmap64(gBegin, os::kPageSize, PROT_READ | PROT_WRITE, + MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT, -1, 0); + GRANARY_ASSERT(!errno && "Unable to map instrumentation page."); + + arch::InitInstrumentationFunctions(reinterpret_cast(gBegin)); + + GRANARY_IF_ASSERT( errno = 0; ) + mprotect(gBegin, os::kPageSize, PROT_READ | PROT_EXEC); + GRANARY_ASSERT(!errno && "Unable to write-protect instrumentation page."); +} + +} // namespace + +// Insert into the LRU cache. The cache is accessed from within the assembly +// in `cache.S`. +void InsertIntoInlineCache(const os::Process32 *process, index::Key key, + index::Value block) { + kCacheIsEmpty = false; + auto offset = process->last_branch_pc % kNumEntries; + auto probe = (gNextInlineCacheEntry[offset]++) % kProbesPerEntry; + auto &entry = gInlineCache[offset + probe]; + entry.app_pc = key.pc32; + entry.cache_pc = static_cast( + reinterpret_cast(gBeginSyncPC) + block.cache_offset); +} + +void ClearInlineCache(void) { + if (!kCacheIsEmpty) { + memset(gInlineCache, 0, sizeof gInlineCache); + kCacheIsEmpty = true; + } +} + +// Initialize the code cache. +void Init(void) { + if (FLAGS_persist) { + sprintf(gCachePath, "%s/grr.cache.persist", FLAGS_persist_dir.c_str()); + GRANARY_IF_ASSERT( errno = 0; ) + gFd = open(gCachePath, O_RDWR | O_CLOEXEC | O_CREAT | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open persisted code cache file."); + } else { + gMMapFlags = MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT; + } + + GRANARY_IF_ASSERT( errno = 0; ) + gBegin = mmap64(nullptr, k250MiB, PROT_NONE, + MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_32BIT, + -1, 0); + GRANARY_ASSERT(!errno && "Unable to map address space for code cache."); + + // The first page of the code cache is for instrumentation. + InitInstrumentation(); + + gBeginSyncPC = reinterpret_cast(gBegin) + os::kPageSize; + gBeginSync = gBeginSyncPC; + gEnd = gBeginSyncPC; + gNextBlockPC = gBeginSyncPC; + + gCacheAddr = gBeginSync; + + if ((gCacheSize = ExistingCacheSize())) { + GRANARY_DEBUG( std::cerr << "Reviving cache file." << std::endl; ) + + auto scaled_cache_size = (gCacheSize + (os::kPageSize - 1)) & os::kPageMask; + + // Scale the cache file out to a multiple of the page size so that we can + // mmap it. + GRANARY_IF_ASSERT( errno = 0; ) + ftruncate64(gFd, static_cast(scaled_cache_size)); + GRANARY_ASSERT(!errno && "Unable to scale the code cache file."); + + // Bring the old cache into memory, although scale it out. We'll keep as + // many of the original cache pages non-writable, just in case this helps + // us to catch spurious bugs. + GRANARY_IF_ASSERT( errno = 0; ) + mmap64(gBeginSync, scaled_cache_size, PROT_READ | PROT_WRITE | PROT_EXEC, + gMMapFlags, gFd, 0); + GRANARY_ASSERT(!errno && "Unable to map the scaled code cache file."); + + gNextBlockPC += gCacheSize; + gCacheSize = scaled_cache_size; + gEnd = gBeginSyncPC + scaled_cache_size; + } +} + +void Exit(void) { + if (!FLAGS_persist || !gSyncCache) return; + auto actual_cache_size = gNextBlockPC - gBeginSyncPC; + msync(gBeginSync, gCacheSize, MS_SYNC | MS_INVALIDATE); + munmap(gBegin, k250MiB); + ftruncate64(gFd, actual_cache_size); + close(gFd); +} + +// Allocate `num_bytes` of space from the code cache. +CachePC Allocate(size_t num_bytes) { + gSyncCache = true; + auto ret = gNextBlockPC; + gNextBlockPC += num_bytes; + if (GRANARY_UNLIKELY(gNextBlockPC > gEnd)) ResizeCache(); + return ret; +} + +// Returns true if the PC is inside the code cache. +bool IsCachePC(uintptr_t pc) { + auto begin = reinterpret_cast(gBeginSyncPC); + return pc >= begin && pc < (begin + gCacheSize); +} + +// Returns the offset of some code within the code cache. +CacheOffset PCToOffset(CachePC pc) { + return static_cast(pc - gBeginSyncPC); +} + +// Returns the program counter associated with some offset within the +// code cache. +CachePC OffsetToPC(CacheOffset offset) { + return gBeginSyncPC + offset; +} + +} // namespace cache +} // namespace granary diff --git a/granary/code/cache.h b/granary/code/cache.h new file mode 100644 index 0000000..849cb73 --- /dev/null +++ b/granary/code/cache.h @@ -0,0 +1,56 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_CODE_CACHE_H_ +#define GRANARY_CODE_CACHE_H_ + +#include "granary/code/index.h" + +namespace granary { +namespace os { +class Process32; +} // namespace os + +namespace cache { + +// Insert into the LRU cache. The cache is accessed from within the assembly +// in `cache.S`. +void InsertIntoInlineCache(const os::Process32 *process, index::Key key, + index::Value value); + +// Clear the inline cache. +void ClearInlineCache(void); + +// Calls into the code cache and returns a continuation. +// +// Note: This function is defined in assembly. +index::Value Call(os::Process32 *process, CachePC cache_pc); + +// Initialize the code cache. +void Init(void); + +// Tear down the code cache. +void Exit(void); + +// Allocate `num_bytes` of space from the code cache. +// +// Note: This function is NOT thread-safe. +CachePC Allocate(size_t num_bytes); + +// Returns true if the PC is inside the code cache. +bool IsCachePC(uintptr_t pc); + +inline static bool IsCachePC(intptr_t pc) { + return IsCachePC(static_cast(pc)); +} + +// Returns the offset of some code within the code cache. +CacheOffset PCToOffset(CachePC pc); + +// Returns the program counter associated with some offset within the +// code cache. +CachePC OffsetToPC(CacheOffset offset); + +} // namespace cache +} // namespace granary + +#endif // GRANARY_CODE_CACHE_H_ diff --git a/granary/code/coverage.cc b/granary/code/coverage.cc new file mode 100644 index 0000000..9fd539d --- /dev/null +++ b/granary/code/coverage.cc @@ -0,0 +1,249 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + + +#include "granary/os/page.h" + +#include "granary/code/instrument.h" +#include "granary/code/coverage.h" + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include "../../third_party/md5/md5.h" + +DECLARE_bool(path_coverage); +DECLARE_string(coverage_file); +DECLARE_string(output_coverage_file); + +namespace granary { + +extern "C" size_t gInputIndex; + +namespace code { + +struct PathEntry { + Addr32 block_pc_of_last_branch; + Addr32 block_pc_of_branch; + Addr32 target_block_pc_of_branch; + + bool operator<(const PathEntry &other) const { + if (block_pc_of_last_branch < other.block_pc_of_last_branch) { + return true; + } else if (block_pc_of_last_branch > other.block_pc_of_last_branch) { + return false; + } + + if (block_pc_of_branch < other.block_pc_of_branch) { + return true; + } else if (block_pc_of_branch > other.block_pc_of_branch) { + return false; + } + + return target_block_pc_of_branch < other.target_block_pc_of_branch; + } +} __attribute__((packed)); + +namespace { + +static std::set gAllPaths; +static std::set gAllPathsAtInit; +static std::set gCurrPaths; + +static bool gHasNewPathCoverage = false; +static bool gInputLengthMarked = false; +static size_t gMarkedInputLength = 0; + +enum : size_t { + kMaxNumBufferedPathEntries = 4096 +}; + +} // namespace + +extern "C" { + +PathEntry gPathEntries[kMaxNumBufferedPathEntries] = {}; +unsigned gNextPathEntry = 0; + +// Used for path tracing. +extern void CoverPath(void); + +// Invoked by assembly +extern void UpdateCoverageSet(void) { + if (!gNextPathEntry) { + return; + } + gNextPathEntry = 0; + auto old_size = gAllPaths.size(); + for (auto &entry : gPathEntries) { + if (!entry.block_pc_of_branch) { + break; + } + gAllPaths.insert(entry); // Cross code-coverage paths. + gCurrPaths.insert(entry); // Execution-specific paths. + entry = {0, 0, 0}; + } + + gHasNewPathCoverage = gHasNewPathCoverage || gAllPaths.size() != old_size; +} + +} // extern C + +void InitPathCoverage(void) { + if (!FLAGS_path_coverage) { + return; + } + + // Multi-way branches (jCC, call r/m, jmp r/m, and ret) are the only + // possible input-dependent branches. Direct jumps and calls are ignored + // because they contribute no new information. + granary::code::AddInstrumentationFunction( + granary::code::InstrumentationPoint::kInstrumentMultiWayBranch, + CoverPath); + + if (FLAGS_coverage_file.empty() || + FLAGS_coverage_file == "/dev/null") { + return; + } + + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open64(FLAGS_coverage_file.c_str(), + O_RDONLY | O_CLOEXEC | O_CREAT | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open a coverage file."); + + struct stat file_info; + fstat(fd, &file_info); + GRANARY_ASSERT(!errno && "Unable to stat the coverage file."); + + auto size = static_cast(file_info.st_size); + + // Likely that we just created the coverage file. + if (!size) { + close(fd); + return; + } + + // Verify that we have the right number of entries. + GRANARY_ASSERT(0 == (size % sizeof(PathEntry))); + + auto num_entries = size / sizeof(PathEntry); + for (size_t i = 0; i < num_entries; ) { + auto bytes_read_ = read(fd, &(gPathEntries[0]), sizeof(gPathEntries)); + GRANARY_ASSERT(!errno && "Unable to read path entries."); + + // Figure out how many entries we've read. + auto bytes_read = static_cast(bytes_read_); + auto num_entries_read = bytes_read / sizeof(PathEntry); + GRANARY_ASSERT(num_entries_read < kMaxNumBufferedPathEntries); + + i += num_entries_read; + + // We didn't read a complete number of entries; back us up. + if (0 != (bytes_read % sizeof(PathEntry))) { + lseek(fd, static_cast(i * sizeof(PathEntry)), SEEK_SET); + GRANARY_ASSERT(!errno && "Unable to seek to valid path entry."); + } + + // Process the entries that we have read. + for (size_t e = 0; e < num_entries_read; ++e) { + gAllPathsAtInit.insert(gPathEntries[e]); + } + } + + close(fd); + ResetPathCoverage(); +} + +void BeginPathCoverage(void) { + gInputLengthMarked = false; + gMarkedInputLength = 0; + gNextPathEntry = 0; + gHasNewPathCoverage = false; + gCurrPaths.clear(); + memset(&(gPathEntries[0]), 0, sizeof(gPathEntries)); +} + +void EndPathCoverage(void) { + UpdateCoverageSet(); + MarkCoveredInputLength(); +} + +bool CoveredNewPaths(void) { + return FLAGS_path_coverage && gHasNewPathCoverage; +} + +void ExitPathCoverage(void) { + if (!FLAGS_path_coverage) { + return; + } + + if (FLAGS_output_coverage_file.empty() || + FLAGS_output_coverage_file == "/dev/null") { + return; + } + + std::stringstream ss; + ss << FLAGS_output_coverage_file << "." << getpid(); + auto cov_file = ss.str(); + + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open64( + cov_file.c_str(), + O_RDWR | O_CLOEXEC | O_CREAT | O_LARGEFILE | O_TRUNC, + 0666); + GRANARY_ASSERT(!errno && "Unable to open a coverage file."); + + for (const auto &entry : gAllPaths) { + if (entry.block_pc_of_branch) { + write(fd, &(entry), sizeof(entry)); + } + } + + close(fd); + rename(cov_file.c_str(), FLAGS_output_coverage_file.c_str()); +} + +void ResetPathCoverage(void) { + gAllPaths = gAllPathsAtInit; +} + +std::string PathCoverageHash(void) { + MD5 hash; + for (const auto &entry : gCurrPaths) { + if (entry.block_pc_of_branch) { + hash.update(reinterpret_cast(&entry), sizeof(entry)); + } + } + + hash.finalize(); + return hash.hexdigest(); +} + +void MarkCoveredInputLength(void) { + if (FLAGS_path_coverage && gHasNewPathCoverage && !gInputLengthMarked) { + GRANARY_ASSERT(gInputIndex && + "Cannot cover new code without reading inputs."); + gMarkedInputLength = gInputIndex; + gInputLengthMarked = true; + } +} + +size_t GetCoveredInputLength(void) { + GRANARY_ASSERT( + gHasNewPathCoverage && gInputLengthMarked && gMarkedInputLength && + "Can't get coverage index for no new coverage."); + return gMarkedInputLength; +} + +size_t GetNumCoveredPaths(void) { + return gCurrPaths.size(); +} + +} // namespace code +} // namespace granary diff --git a/granary/code/coverage.h b/granary/code/coverage.h new file mode 100644 index 0000000..e29d7a9 --- /dev/null +++ b/granary/code/coverage.h @@ -0,0 +1,25 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef CLIENT_COVERAGE_H_ +#define CLIENT_COVERAGE_H_ + +#include + +namespace granary { +namespace code { + +void InitPathCoverage(void); +void BeginPathCoverage(void); +void EndPathCoverage(void); +void ExitPathCoverage(void); +void ResetPathCoverage(void); +bool CoveredNewPaths(void); +std::string PathCoverageHash(void); +void MarkCoveredInputLength(void); +size_t GetCoveredInputLength(void); +size_t GetNumCoveredPaths(void); + +} // namespace code +} // namespace granary + +#endif // CLIENT_COVERAGE_H_ diff --git a/granary/code/execute.cc b/granary/code/execute.cc new file mode 100644 index 0000000..144c893 --- /dev/null +++ b/granary/code/execute.cc @@ -0,0 +1,162 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/execute.h" + +#include "granary/code/block.h" +#include "granary/code/cache.h" +#include "granary/code/index.h" +#include "granary/code/trace.h" + +#include "granary/os/process.h" + +#include + +#include +#include + +DEFINE_bool(disable_tracing, false, "Disable building superblocks."); +DEFINE_bool(disable_inline_cache, false, "Disable the inline cache."); +DEFINE_bool(debug_print_executions, false, "Print all block executions."); +DEFINE_bool(debug_print_pcs, false, "Print PCs executed by the program."); + +namespace granary { +namespace code { +namespace { + +// Translate a block. +static index::Value Translate(os::Process32 *process, index::Key key) { + Block block; + + // Safely reads instruction bytes into memory. This only reads bytes that are + // both executable and readable. + block.Decode(key.pc32, [=] (Addr32 pc32, uint8_t &byte) -> bool { + auto pc64 = process->ConvertPC(pc32); + if (!process->TryRead(pc64, byte)) return false; + if (!process->CanExecute(pc32)) return false; + return true; + }); + + index::Value val; + val.block_pc32 = key.pc32; + block.Encode(val); + return val; +} + +} // namespace + +// Main interpreter loop. This function handles index lookup, block translation, +// trace building, and dispatching. +// +// Note: We need to be very careful with functions that might modify global +// state. All such functions *must* be wrapped in code that disables +// interrupts. +__attribute__((noinline)) +void Execute(os::Process32 *process) { + TraceRecorder trace; + for (;;) { + index::Key key; + index::Value block; + + // Try to find the block to execute. If we don't find it, then we + // probably haven't translated it for this hash. Given that we likely + // need to translate something, go and check that the current and + // potentially the next pages (because a block can cross at most two + // pages) are both hashed, otherwise invalidate the hash and re-do + // the lookup. + for (;;) { + Uninterruptible disable_interrupts; + key = index::Key(process, process->PC()); // Might hash page ranges. + block = index::Find(key); + if (GRANARY_LIKELY(block)) { + break; + + } else if (GRANARY_UNLIKELY(process->TryMakeExecutable())) { + continue; + + } else { + block = Translate(process, key); + index::Insert(key, block); + cache::ClearInlineCache(); + break; + } + } + + // TODO(pag): Why does this need to go before trace building, and why + // do I need to check that the target block doesn't end with a + // system call or error? + if (!FLAGS_disable_inline_cache && + !block.ends_with_error && + !block.ends_with_syscall) { + cache::InsertIntoInlineCache(process, key, block); + } + + // If we can't extend the trace, then build the trace block. + if (!FLAGS_disable_tracing && trace.BlockEndsTrace(key, block)) { + Uninterruptible disable_interrupts; + trace.Build(); + } + + if (FLAGS_debug_print_executions) { + std::cerr << process->Id() << std::hex + << " EIP=" << process->PC() + << " EAX=" << process->regs.eax + << " EBX=" << process->regs.ebx + << " ECX=" << process->regs.ecx + << " EDX=" << process->regs.edx + << " EDI=" << process->regs.edi + << " ESI=" << process->regs.esi + << " EBP=" << process->regs.ebp + << " ESP=" << process->regs.esp + << std::dec << std::endl; + } + + if (FLAGS_debug_print_pcs) { + std::cerr << std::hex << process->PC() << std::endl; + } + + process->signal = 0; + + // Call into the code cache. This returns the `index::Value` of the last + // block executed. This is important in the case of traces and persistent + // caches, where the jumps might be hot-patched, thus leading to syscalls. + process->RestoreFPUState(); + block = cache::Call(process, cache::OffsetToPC(block.cache_offset)); + process->SaveFPUState(); + + // At the time of translating the block, we determined that the block + // ended in either an invalid instruction, or crossed into a non- + // executable page. We execute all instructions up to that point, then + // flag the error. + // + // The other way of getting here is via a fault that redirected execution + // within `cache::Call` to go to `granary_bad_block`, which cleanly + // returns from the code cache. + if (block.ends_with_error) { + if (SIGFPE == process->signal) { + process->status = os::ProcessStatus::kIgnorableError; + } else { + process->status = os::ProcessStatus::kError; + } + if (!process->signal) { + process->signal = SIGILL; // Decode-time deduction. + } + process->exec_status = os::ExecStatus::kInvalid; + return; + } + + // Go execute a system call. + if (block.ends_with_syscall) { + process->status = os::ProcessStatus::kSystemCall; + process->exec_status = os::ExecStatus::kReady; + return; + } + } + + // Shouldn't be reachable. + GRANARY_ASSERT(false && "Fell off the end of the interpreter!"); + process->status = os::ProcessStatus::kError; + process->exec_status = os::ExecStatus::kInvalid; +} + +} // namespace code +} // namespace granary diff --git a/granary/code/execute.h b/granary/code/execute.h new file mode 100644 index 0000000..a9c7e0a --- /dev/null +++ b/granary/code/execute.h @@ -0,0 +1,18 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_EXECUTE_H_ +#define GRANARY_EXECUTE_H_ + +#include "granary/os/schedule.h" + +namespace granary { +namespace code { + +// Main interpreter loop. This function handles index lookup, block translation, +// trace building, dispatching, and system call handling. +void Execute(os::Process32 *process); + +} // namespace code +} // namespace granary + +#endif // GRANARY_EXECUTE_H_ diff --git a/granary/code/index.cc b/granary/code/index.cc new file mode 100644 index 0000000..3cd348b --- /dev/null +++ b/granary/code/index.cc @@ -0,0 +1,172 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/index.h" + +#include + +#include + +#include +#include + +#include +#include + +#include +#include +#include + +#include "../../third_party/xxhash/xxhash.h" + +DECLARE_bool(persist); +DECLARE_string(persist_dir); + +namespace granary { +namespace index { +namespace { + +enum : uint64_t { + kMaxNumProbes = 6, + kMinNumEntries = 4 +}; + +struct Entry { + Key key; + Value val; +}; + +struct Hash { + size_t operator()(const Key key) const { + XXH64_state_t state; + XXH64_reset(&state, 0xff51afd7ed558ccdULL); + XXH64_update(&state, &key, sizeof key); + return XXH64_digest(&state); + } +}; + +// Pointer to the currently active index. +static std::unordered_map gTable; + +// Path to the persisted cache file. +static char gIndexPath[256] = {'\0'}; + +// Was there an old index file before this one? +static bool gOldIndexExists = false; + +// Should the index be synced with the file system? +static bool gSyncIndex = false; + +// Opens or re-opens the backing file for the index. +static void ReviveCache(void) { + if (!FLAGS_persist) return; + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open(gIndexPath, O_CREAT | O_RDWR | O_CLOEXEC | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open persisted code cache index file."); + + struct stat64 info; + fstat64(fd, &info); + GRANARY_ASSERT(!errno && "Could stat code cache index file."); + + // Existing file is empty; nothing to revive. + if (!info.st_size) { + close(fd); + return; + } + + GRANARY_DEBUG( std::cerr << "Reviving index file." << std::endl; ) + + gOldIndexExists = true; + + auto size = static_cast(info.st_size); + auto num_entries = size / sizeof(Entry); + + auto scaled_size = (size + os::kPageSize - 1) & os::kPageMask; + if (scaled_size > size) { + ftruncate64(fd, static_cast(scaled_size)); + GRANARY_ASSERT(!errno && "Could not scale code cache index file."); + } + auto ret = mmap64(nullptr, scaled_size, PROT_READ, + MAP_PRIVATE | MAP_POPULATE, fd, 0); + GRANARY_ASSERT(!errno && "Could not map code cache index file."); + + gTable.reserve(num_entries); + auto entry = reinterpret_cast(ret); + for (auto i = 0UL; i < num_entries; ++i, ++entry) { + gTable[entry->key] = entry->val; + } + + munmap(ret, scaled_size); + close(fd); +} + +} // namespace + +// Initialize the code cache index. +void Init(void) { + if (!FLAGS_persist) return; + sprintf(gIndexPath, "%s/grr.index.persist", FLAGS_persist_dir.c_str()); + ReviveCache(); +} + +// Exit the code cache index. +void Exit(void) { + if (!FLAGS_persist || !gSyncIndex) return; + + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open(gIndexPath, O_CREAT | O_RDWR | O_CLOEXEC | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open persisted code cache index file."); + + if (gOldIndexExists) { + ftruncate64(fd, 0); + GRANARY_ASSERT(!errno && "Could not clear stale code cache index file."); + } + + auto size = sizeof(Entry) * gTable.size(); + auto scaled_size = (size + os::kPageSize - 1) & os::kPageMask; + + ftruncate64(fd, static_cast(scaled_size)); + GRANARY_ASSERT(!errno && "Could not scale new code cache index file."); + + auto ret = mmap64(nullptr, scaled_size, PROT_READ | PROT_WRITE, + MAP_SHARED, fd, 0); + GRANARY_ASSERT(!errno && "Could not map new code cache index file."); + + // Serialize. + auto entry = reinterpret_cast(ret); + for (const auto &key_val : gTable) { + if (key_val.second) *entry++ = {key_val.first, key_val.second}; + } + + // Persist. + msync(ret, scaled_size, MS_SYNC | MS_INVALIDATE); + munmap(ret, scaled_size); + + // Truncate. + if (size < scaled_size) { + ftruncate64(fd, static_cast(size)); + GRANARY_ASSERT(!errno && "Could resize new code cache index file."); + } +} + +// Print out all entries in the code cache index. +void Dump(void) { + for (const auto &entry : gTable) { + auto pc = entry.first.pc32; + auto pid = entry.first.pid; + std::cout << std::dec << pid << " " << std::hex << pc << std::endl; + } +} + +// Finds a value in the index given a key. +Value Find(const Key key) { + return gTable[key]; // If not there, this will create space. +} + +// Inserts a (key, value) pair into the index. +void Insert(Key key, Value value) { + gSyncIndex = true; + gTable[key] = value; +} + +} // namespace index +} // namespace granary diff --git a/granary/code/index.h b/granary/code/index.h new file mode 100644 index 0000000..f9e47d4 --- /dev/null +++ b/granary/code/index.h @@ -0,0 +1,120 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_CODE_INDEX_H_ +#define GRANARY_CODE_INDEX_H_ + +#include "granary/base/base.h" + +#include "granary/os/process.h" + +namespace granary { +namespace index { + +union Key { + inline Key(void) + : key(0ULL) {} + + inline Key(os::Process32 *process, AppPC32 pc) + : pc32(pc), + pid(process->Id()), + code_hash(process->PageHash()) {} + + inline operator bool(void) const { + return 0 != key; + } + + inline bool operator==(const Key &that) const { + return key == that.key; + } + + inline bool operator!=(const Key &that) const { + return key != that.key; + } + + uint64_t key; + + struct { + // The 32-bit program counter in the process associated with `pid` that + // begins this block. + AppPC32 pc32; + + // The ID of this binary. We will often put blocks from multiple binaries + // into a single code cache. + pid_t pid:8; + + // Hash of all executable pages. + uint32_t code_hash:24; + + } __attribute__((packed)); +}; + +union Value { + inline Value(void) + : value(0ULL) {} + + inline operator bool(void) const { + return 0 != value; + } + + inline bool IsTraceHead(void) const { + return is_trace_head; + } + + uint64_t value; + + struct { + // A non-unique block ID that includes part of the AppPC32 and the PID. + uint32_t block_pc32; + + // Offset of the translated block within the code cache. + CacheOffset cache_offset:27; + + // Is this the first block in a trace? + bool is_trace_head:1; + + // Is this block part of a trace? + bool is_trace_block:1; + + // Does this block have only a single successor? + bool has_one_successor:1; + + // Does this block end with a system call? + bool ends_with_syscall:1; + + // Does this block end in an undefined instruction? This signals one of a + // few conditions: + // 1) Failure to decode an instruction. + // 2) Instruction crosses from an executable into a non-executable + // page. + // 3) Instruction is in an unmapped or unreadable page. + // 4) Emulated code actually contained UD2 or other undefined + // instruction. + bool ends_with_error:1; + } __attribute__((packed)); +}; + +static_assert(sizeof(Key) <= sizeof(uint64_t), + "Invalid structure packing of `IndexKey`."); + +static_assert(sizeof(Value) <= sizeof(uint64_t), + "Invalid structure packing of `IndexKey`."); + +// Initialize the code cache index. +void Init(void); + +// Exit the code cache index. +void Exit(void); + +// Print out all entries in the code cache index. +void Dump(void); + +// Finds a value in the index given a key. +Value Find(const Key search_key); + +// Inserts a (key, value) pair into the index. +void Insert(const Key key, Value value); + +} // namespace index +} // namespace granary + +#endif // GRANARY_CODE_INDEX_H_ diff --git a/granary/code/instruction.cc b/granary/code/instruction.cc new file mode 100644 index 0000000..6eedd3a --- /dev/null +++ b/granary/code/instruction.cc @@ -0,0 +1,124 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/instruction.h" + +namespace granary { + +bool Instruction::IsFunctionCall(void) const { + return instruction.IsFunctionCall(); +} + +bool Instruction::IsFunctionReturn(void) const { + return instruction.IsFunctionReturn(); +} + +bool Instruction::IsInterruptCall(void) const { + return instruction.IsInterruptCall(); +} + +bool Instruction::IsInterruptReturn(void) const { + return instruction.IsInterruptReturn(); +} + +bool Instruction::IsSystemCall(void) const { + return instruction.IsSystemCall(); +} + +bool Instruction::IsSystemReturn(void) const { + return instruction.IsSystemReturn(); +} + +bool Instruction::IsJump(void) const { + return instruction.IsJump(); +} + +bool Instruction::IsBranch(void) const { + return instruction.IsBranch(); +} + +bool Instruction::IsDirectFunctionCall(void) const { + return instruction.IsDirectFunctionCall(); +} + +bool Instruction::IsIndirectFunctionCall(void) const { + return instruction.IsIndirectFunctionCall(); +} + +bool Instruction::IsDirectJump(void) const { + return instruction.IsDirectJump(); +} + +bool Instruction::IsIndirectJump(void) const { + return instruction.IsIndirectJump(); +} + +bool Instruction::IsSerializing(void) const { + return instruction.IsSerializing(); +} + +bool Instruction::IsUndefined(void) const { + return instruction.IsUndefined(); +} + +// Beginning program counter of this instruction. +AppPC32 Instruction::StartPC(void) const { + return instruction.StartPC(); +} + +// Program counter of the next logical instruction after this instruction. +AppPC32 Instruction::EndPC(void) const { + return instruction.EndPC(); +} + +// Size of this instruction in bytes. +size_t Instruction::NumBytes(void) const { + return instruction.NumBytes(); +} + +// Target of a branch, direct jump, or direct call. These only work on +// their respective, non-indirect instruction kinds. +AppPC32 Instruction::BranchTakenPC(void) const { + GRANARY_ASSERT(IsBranch()); + return instruction.TargetPC(); +} + +AppPC32 Instruction::BranchNotTakenPC(void) const { + GRANARY_ASSERT(IsBranch()); + return EndPC(); +} + +AppPC32 Instruction::JumpTargetPC(void) const { + GRANARY_ASSERT(IsDirectJump()); + return instruction.TargetPC(); +} + +AppPC32 Instruction::FunctionCallTargetPC(void) const { + GRANARY_ASSERT(IsDirectFunctionCall()); + return instruction.TargetPC(); +} +InstructionIterator::InstructionIterator(Instruction *cursor_) + : cursor(cursor_) {} + +Instruction *InstructionIterator::operator*(void) const { + return cursor; +} + +InstructionIterator &InstructionIterator::operator++(void) { + ++cursor; + return *this; +} + +ReverseInstructionIterator::ReverseInstructionIterator( + Instruction *cursor_) + : cursor(cursor_) {} + +Instruction *ReverseInstructionIterator::operator*(void) const { + return cursor; +} + +ReverseInstructionIterator &ReverseInstructionIterator::operator++(void) { + --cursor; + return *this; +} + +} // namespace granary diff --git a/granary/code/instruction.h b/granary/code/instruction.h new file mode 100644 index 0000000..e99fa5c --- /dev/null +++ b/granary/code/instruction.h @@ -0,0 +1,101 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_CODE_INSTRUCTION_H_ +#define GRANARY_CODE_INSTRUCTION_H_ + +#include "granary/arch/instruction.h" + +namespace granary { + +// Represents a decoded application instruction that can be instrumented. +class Instruction final { + public: + Instruction(void) = default; + + bool IsFunctionCall(void) const; + bool IsFunctionReturn(void) const; + bool IsInterruptCall(void) const; + bool IsInterruptReturn(void) const; + bool IsSystemCall(void) const; + bool IsSystemReturn(void) const; + bool IsJump(void) const; + bool IsBranch(void) const; + + bool IsDirectFunctionCall(void) const; + bool IsIndirectFunctionCall(void) const; + + bool IsDirectJump(void) const; + bool IsIndirectJump(void) const; + + bool IsSerializing(void) const; + bool IsUndefined(void) const; + + bool IsNoOp(void) const; + + // Beginning program counter of this instruction. + AppPC32 StartPC(void) const; + + // Program counter of the next logical instruction after this instruction. + AppPC32 EndPC(void) const; + + // Size of this instruction in bytes. + size_t NumBytes(void) const; + + // Target of a branch, direct jump, or direct call. These only work on + // their respective, non-indirect instruction kinds. + AppPC32 BranchTakenPC(void) const; + AppPC32 BranchNotTakenPC(void) const; + AppPC32 JumpTargetPC(void) const; + AppPC32 FunctionCallTargetPC(void) const; + + GRANARY_PROTECTED: + // Internal architecture-specific instruction. + arch::Instruction instruction; +}; + +// Iterate forward over application instructions. +class InstructionIterator { + public: + InstructionIterator(const InstructionIterator &) = default; + InstructionIterator(InstructionIterator &&) = default; + + explicit InstructionIterator(Instruction *cursor_); + + inline bool operator!=(const InstructionIterator &that) const { + return cursor != that.cursor; + } + + Instruction *operator*(void) const; + InstructionIterator &operator++(void); + + private: + InstructionIterator(void) = delete; + + Instruction *cursor; +}; + +// Iterate backward over instructions. +class ReverseInstructionIterator { + public: + ReverseInstructionIterator( + const ReverseInstructionIterator &) = default; + ReverseInstructionIterator(ReverseInstructionIterator &&) = default; + + explicit ReverseInstructionIterator(Instruction *cursor_); + + inline bool operator!=(const ReverseInstructionIterator &that) const { + return cursor != that.cursor; + } + + Instruction *operator*(void) const; + ReverseInstructionIterator &operator++(void); + + private: + ReverseInstructionIterator(void) = delete; + + Instruction *cursor; +}; + +} // namespace + +#endif // GRANARY_CODE_INSTRUCTION_H_ diff --git a/granary/code/instrument.cc b/granary/code/instrument.cc new file mode 100644 index 0000000..9daab59 --- /dev/null +++ b/granary/code/instrument.cc @@ -0,0 +1,56 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include +#include + +#include "granary/code/instrument.h" + +namespace granary { +namespace code { +namespace { + +static uintptr_t gInstFuncs[InstrumentationPoint::kInvalid] = {0}; +static std::unordered_map gPCInstFuncs; + +static const InstrumentationIds gNoPCFunc = {}; + +static unsigned gNextPCId = 0; + +} // namespace + +// Adds an instrumentation function. +void AddInstrumentationFunction(InstrumentationPoint ipoint, + void (*func)(void)) { + // This works as long as: + // 1) The code cache is allocated as `MAP_32BIT`. + // 2) The build of `grr` doesn't change across two + // uses of a persisted code cache. This part is *REALLY* important. + gInstFuncs[ipoint] = reinterpret_cast(func); +} + +// Set the value of the sole to the PC instrumentation function. +void AddPCInstrumentation(Addr32 pc) { + auto id = gNextPCId++; + if (pc) { + gPCInstFuncs[pc].push_back(id); + } +} + +// Returns the location in the code cache of where this instrumentation +// function is. +uintptr_t GetInstrumentationFunction(InstrumentationPoint ipoint) { + GRANARY_ASSERT(InstrumentationPoint::kInvalid != ipoint); + return gInstFuncs[ipoint]; +} + +const InstrumentationIds &GetInstrumentationIds(Addr32 pc) { + auto x = gPCInstFuncs.find(pc); + if (x == gPCInstFuncs.end()) { + return gNoPCFunc; + } else { + return x->second; + } +} + +} // namespace code +} // namespace granary diff --git a/granary/code/instrument.h b/granary/code/instrument.h new file mode 100644 index 0000000..0980cc3 --- /dev/null +++ b/granary/code/instrument.h @@ -0,0 +1,38 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_INSTRUMENT_H_ +#define GRANARY_INSTRUMENT_H_ + +#include + +#include "granary/base/base.h" + +namespace granary { +namespace code { + +enum InstrumentationPoint { + kInstrumentMultiWayBranch = 0, + kInstrumentBlockEntry = 1, + kInstrumentPC = 2, + kInstrumentMemoryAddress = 3, + kInvalid +}; + +typedef std::vector InstrumentationIds; + +// Adds an instrumentation function. +void AddInstrumentationFunction(InstrumentationPoint ipoint, + void (*func)(void)); + +void AddPCInstrumentation(Addr32 pc); + +// Returns the location in the code cache of where this instrumentation +// function is. +uintptr_t GetInstrumentationFunction(InstrumentationPoint ipoint); + +const InstrumentationIds &GetInstrumentationIds(Addr32 pc); + +} // namespace code +} // namespace granary + +#endif // GRANARY_INSTRUMENT_H_ diff --git a/granary/code/trace.cc b/granary/code/trace.cc new file mode 100644 index 0000000..0f87076 --- /dev/null +++ b/granary/code/trace.cc @@ -0,0 +1,28 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/code/trace.h" + +namespace granary { + +TraceRecorder::TraceRecorder(void) + : next_entry(0) + , trace_length(0) + , entries{} {} + +bool TraceRecorder::BlockEndsTrace(index::Key key, index::Value block) { + auto &entry = entries[next_entry++]; + entry.key = key; + entry.val = block; + + if (block.ends_with_syscall || block.ends_with_error || + !block.has_one_successor || block.is_trace_block || + kMaxNumTraceEntries == next_entry) { + trace_length = next_entry; + next_entry = 0; + return true; + } else { + return false; + } +} + +} // namespace granary diff --git a/granary/code/trace.h b/granary/code/trace.h new file mode 100644 index 0000000..8b5dd05 --- /dev/null +++ b/granary/code/trace.h @@ -0,0 +1,49 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_CODE_TRACE_H_ +#define GRANARY_CODE_TRACE_H_ + +#include "granary/code/index.h" + +namespace granary { + +enum : size_t { + kMaxNumTraceEntries = 32 +}; + +struct TraceEntry { + index::Key key; + index::Value val; +}; + +class TraceRecorder { + public: + TraceRecorder(void); + + // Record an entry into a trace. + bool BlockEndsTrace(index::Key key, index::Value val); + + // Build a trace. + // + // Note: This has an architecture-specific implementation. + // + // Note: This function is NOT thread-safe. + void Build(void); + + // Returns true if the trace buffer is empty. + inline bool IsEmpty(void) const { + return !trace_length; + } + + private: + size_t next_entry; + size_t trace_length; + TraceEntry entries[kMaxNumTraceEntries]; + + GRANARY_DISALLOW_COPY_AND_ASSIGN(TraceRecorder); +}; + + +} // namespace granary + +#endif // GRANARY_CODE_TRACE_H_ diff --git a/granary/input/mutate.cc b/granary/input/mutate.cc new file mode 100644 index 0000000..ee420c8 --- /dev/null +++ b/granary/input/mutate.cc @@ -0,0 +1,604 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + + +#include "granary/input/mutate.h" +#include "granary/os/decree_user/decree.h" + +#include +#include +#include +#include "../../third_party/radamsa/radamsa.h" +#include "../../third_party/xxhash/xxhash.h" + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-undefined-compare" + +namespace granary { +namespace input { +namespace { + +static bool IsInput(const IOSystemCall &syscall) { + return IOKind::kInput == syscall.kind; +} + +static size_t NumInputs(const IORecording *record) { + return record->num_inputs; +} + +static size_t MaxInputIndex(const IORecording *record) { + size_t i = 0; + size_t j = 0; + for (const auto &syscall : record->system_calls) { + ++i; + if (IOKind::kInput == syscall.kind) { + ++j; + if (j == record->num_inputs) { + break; + } + } + } + return i; +} + +static size_t NextInputIndex(const IORecording *record, size_t start) { + for (size_t i = start; i < record->system_calls.size(); ++i) { + if (IOKind::kInput == record->system_calls[i].kind) { + return i; + } + } + return record->system_calls.size(); +} + +// Copy a series of system calls (verbatim) within the range of indices. +static void CopyInputs(const IORecording *test, + IORecording *output_test, + size_t begin, + const size_t end) { + for (; begin < end; ++begin) { + const auto &syscall = test->system_calls[begin]; + if (IOKind::kInput == syscall.kind) { + output_test->AddInput(syscall.data); + } + } +} + +// Chunk-canonicalize a testcase. This canonicalizes adjacent receives. +static IORecording *ChunkedCanonicalizeTest( + const IORecording *record, IORecording *canonical_test) { + + auto num_syscalls = record->system_calls.size(); + for (size_t i = 0; i < num_syscalls; ) { + const auto &syscall = record->system_calls[i]; + if (!IsInput(syscall)) { + ++i; + continue; + } + + // Figure out how much data storage we'll need. + size_t reserve_size = 0; + for (auto j = i; j < num_syscalls; ++j) { + const auto &inner_syscall = record->system_calls[j]; + if (!IsInput(inner_syscall)) { + break; + } + reserve_size += inner_syscall.data.size(); + } + + // Allocate the storage. + std::string canonical_data; + canonical_data.reserve(reserve_size); + + // Fill the storage. + for (; i < num_syscalls; ++i) { + const IOSystemCall &inner_syscall = record->system_calls[i]; + if (!IsInput(inner_syscall)) { + break; + } + canonical_data.insert( + canonical_data.end(), + inner_syscall.data.begin(), + inner_syscall.data.end()); + } + + canonical_test->AddInput(std::move(canonical_data)); + } + + return canonical_test; +} + + +// Injects one of the inputs from the testcase into an arbitrary spot within +// the testcase. +template +class SpliceMutator : public Mutator { + public: + SpliceMutator(const IORecording *record_) + : Mutator(record_), + max_prefix_length(0), + num_inputs(NumInputs(record_)), + mutation_index(0), + max_input_index(MaxInputIndex(record_)), + mutate() {} + + virtual ~SpliceMutator(void) = default; + + void Reset(void) { + max_prefix_length = 0; + mutation_index = 0; + } + + virtual IORecording *RequestMutationImpl(void) { + if (max_prefix_length >= num_inputs) { + return nullptr; + } + + auto test = new IORecording; + + // Copy some prefix of the syscalls verbatim. + size_t i = 0; + for (size_t prefix_length = 0; + prefix_length < max_prefix_length && i < max_input_index; + ++i) { + const auto &orig_syscall = record->system_calls[i]; + if (!IsInput(orig_syscall)) { + continue; + } + mutate(test, orig_syscall); + ++prefix_length; + } + + // Go and choose a specific input syscall to move into place somewhere + // within the testcase. In some cases, this acts as a repeater. + for (; mutation_index < max_input_index; ) { + const auto &orig_syscall = record->system_calls[mutation_index++]; + if (!IsInput(orig_syscall)) { + continue; + } + test->AddInput(orig_syscall.data); + break; + } + + // Copy the suffix of the syscalls verbatim. + for (i = NextInputIndex(record, i); i < max_input_index; ++i) { + const auto &orig_syscall = record->system_calls[i]; + if (!IsInput(orig_syscall)) { + continue; + } + test->AddInput(orig_syscall.data); + } + + // Set up for the next iteration. + if (mutation_index >= max_input_index) { + mutation_index = 0; + max_prefix_length += 1; + } + + return test; + } + + private: + size_t max_prefix_length; + const size_t num_inputs; + size_t mutation_index; + const size_t max_input_index; + MutationEngine mutate; +}; + +template +class ChunkedSpliceMutator : public SpliceMutator { + public: + ChunkedSpliceMutator(const IORecording *record_) + : SpliceMutator( + ChunkedCanonicalizeTest(record_, new IORecording)) {} + + virtual ~ChunkedSpliceMutator(void) { + delete this->record; + } +}; + +// Apply a mutator to only one out of all of the input receives. +template +class SliceMutator : public Mutator { + public: + SliceMutator(const IORecording *record_, size_t max_slice_size_=0) + : Mutator(record_), + curr_input_index(NextInputIndex(record_, 0)), + num_inputs(NumInputs(record_)), + max_input_index(MaxInputIndex(record_)), + slice_size(1), + max_slice_size(max_slice_size_ ?: num_inputs), + mutate() {} + + virtual IORecording *RequestMutationImpl(void) { + if (curr_input_index >= max_input_index) { + if (++slice_size > max_slice_size) { + return nullptr; + } else { + curr_input_index = NextInputIndex(record, 0); + } + } + + auto test = new IORecording; + + // Verbatim copy of a prefix. + CopyInputs(record, test, 0, curr_input_index); + + // Mutate a slice of system calls. + auto input_index = curr_input_index; + for (size_t i = 0; i < slice_size && input_index < max_input_index; ++i) { + const auto &curr_syscall = record->system_calls[input_index]; + GRANARY_ASSERT(IsInput(curr_syscall)); + mutate(test, curr_syscall); + input_index = NextInputIndex(record, input_index + 1); + } + + // Verbatim copy of a suffix. + CopyInputs(record, test, input_index, max_input_index); + + // Next iteration moves the slice forward. + curr_input_index = NextInputIndex(record, curr_input_index + 1); + + return test; + } + + void Reset(void) { + curr_input_index = NextInputIndex(record, 0); + slice_size = 1; + } + + protected: + + size_t curr_input_index; + const size_t num_inputs; + const size_t max_input_index; + size_t slice_size; + const size_t max_slice_size; + + MutationEngine mutate; +}; + +template +class ChunkedSliceMutator : public SliceMutator { + public: + ChunkedSliceMutator(const IORecording *record_, size_t max_slice_size_=0) + : SliceMutator( + ChunkedCanonicalizeTest(record_, new IORecording), + max_slice_size_) {} + + virtual ~ChunkedSliceMutator(void) { + delete this->record; + } +}; + +// Concatenate all receives in a testcase, then run a mutation engine on it. +template +class ConcatMutator : public Mutator { + public: + ConcatMutator(const IORecording *record_) + : Mutator(ConcatTestCase(record_)), + mutate() {} + + virtual ~ConcatMutator(void) { + delete record; + } + + virtual IORecording *RequestMutationImpl(void) { + if (!record->num_input_bytes) { + return nullptr; + } + auto test = new IORecording; + mutate(test, record->system_calls[0]); + return test; + } + + private: + static IORecording *ConcatTestCase(const IORecording *record_) { + auto test = new IORecording; + test->AddInput(std::move(record_->ToInput())); + return test; + } + + MutationEngine mutate; +}; + +// Turns a normal mutator into an infinite mutator. +template +class InfiniteMutator : public BaseMutator { + public: + using BaseMutator::BaseMutator; + + virtual ~InfiniteMutator(void) = default; + + virtual IORecording *RequestMutationImpl(void) { + auto test = this->BaseMutator::RequestMutationImpl(); + if (!test) { + this->BaseMutator::Reset(); + test = this->BaseMutator::RequestMutationImpl(); + } + return test; + } +}; + +// Creates a pipeline of mutators. +template +class PipelineMutator : public BaseMutator1 { + public: + PipelineMutator(const IORecording *record_) + : BaseMutator1(record_), + base2(nullptr), + base2_seed(nullptr) {} + + void Reset(void) { + DestroyBase2(); + this->BaseMutator1::Reset(); + } + + virtual IORecording *RequestMutationImpl(void) { + InitBase2(); + if (!base2) { + return nullptr; + } + auto test = base2->RequestMutationImpl(); + if (!test) { + DestroyBase2(); + InitBase2(); + if (!base2) { + test = base2->RequestMutationImpl(); + } + } + return test; + } + + virtual ~PipelineMutator(void) { + DestroyBase2(); + } + + private: + void InitBase2(void) { + if (!base2_seed) { + base2_seed = this->BaseMutator1::RequestMutationImpl(); + } + if (base2_seed && !base2) { + base2 = new (mem) BaseMutator2(base2_seed); + } + } + + void DestroyBase2(void) { + if (base2) base2->~BaseMutator2(); + if (base2_seed) delete base2_seed; + base2 = nullptr; + base2_seed = nullptr; + } + + alignas(BaseMutator2) uint8_t mem[sizeof(BaseMutator2)]; + BaseMutator2 *base2; + const IORecording *base2_seed; +}; + +class IRandomMutator { + public: + IRandomMutator(void) { + XXH32_reset(&state, static_cast(CurrentTSC())); + } + + uint64_t NextRandom(void) { + auto tsc = CurrentTSC(); + XXH32_update(&state, &tsc, sizeof tsc); + return XXH32_digest(&state); + } + + private: + static inline uint64_t CurrentTSC(void) { + uint64_t x; + __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)); + return x; + } + + XXH32_state_t state; +}; + +// Replace all bytes with random bytes. +class RandomizeSyscallMutator : public IRandomMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + std::string output_data; + output_data.reserve(input.data.size()); + for (auto i = 0UL; i < input.data.size(); ++i) { + output_data.push_back(static_cast(NextRandom())); + } + test->AddInput(std::move(output_data)); + } +}; + +// Replace all bytes with random bytes. +class RandomBitFlipSyscallMutator : public IRandomMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + std::string output_data; + output_data.reserve(input.data.size()); + for (auto input_char : input.data) { + auto mask = static_cast(NextRandom()); + output_data.push_back(input_char ^ mask); + } + test->AddInput(std::move(output_data)); + } +}; + +static const size_t kRepeatAmounts[] = { + 0, 1, 2, 10, 100, 1000, 10000 +}; + +class RandomRepeatingSyscallMutator : public IRandomMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + auto repetitions = kRepeatAmounts[NextRandom() % 7UL]; + if (!repetitions) { + return; + } + + std::string output_data; + output_data.reserve(input.data.size() * repetitions); + for (auto i = 0UL; i < repetitions; ++i) { + output_data.insert( + output_data.end(), input.data.begin(), input.data.end()); + } + + test->AddInput(std::move(output_data)); + } +}; + +// Generic bit flipper. +template +class BitFlipSyscallMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + std::string output_data; + output_data.reserve(input.data.size()); + for (auto byte : input.data) { + output_data.push_back( + static_cast(FlipBits(static_cast(byte)))); + } + test->AddInput(std::move(output_data)); + } + + private: + static_assert(1 <= kStartBit, "1 <= kStartBit <= 8"); + static_assert(8 >= kStartBit, "1 <= kStartBit <= 8"); + static_assert(1 <= kNumBits, "1 <= kNumBits <= 8"); + static_assert(8 >= kNumBits, "1 <= kNumBits <= 8"); + + enum : size_t { + kMaskHigh = 0xFFUL << kStartBit, + kMaskLow = 0xFFUL >> (9 - kStartBit), + kMask = kMaskLow | kMaskHigh, + kFlippedMask = ~kMask + }; + + static uint8_t FlipBits(uint8_t byte) { + return static_cast((byte & kMask) | (~byte & kFlippedMask)); + } +}; + +// Drop the syscalls. +class DeletingSyscallMutator { + public: + void operator()(IORecording *, const IOSystemCall &) {} +}; + +// Returns the identity of the system call. +class IdentitySyscallMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + test->AddInput(input.data); + } +}; + +// Use Radamsa to mutate a system call. +class RadamsaSyscallMutator { + public: + void operator()(IORecording *test, const IOSystemCall &input) { + test->AddInput(radamsa::Mutate(input.data)); + } +}; + +} // namespace + + +Mutator::Mutator(const IORecording *record_) + : record(record_) {} + +Mutator::~Mutator(void) {} + +std::string Mutator::RequestMutation(void) { + if (auto req_record = this->RequestMutationImpl()) { + auto ret = req_record->ToInput(); + delete req_record; + return ret; + } else { + return ""; + } +} + +Mutator *Mutator::Create(const IORecording *test, + const std::string &mutator) { + if (mutator == "splice") { + return new SpliceMutator(test); + + } else if (mutator == "splice_chunked") { + return new ChunkedSpliceMutator(test); + + } else if (mutator == "random") { + return new SliceMutator(test); + + } else if (mutator == "dropper") { + return new SliceMutator(test); + + } else if (mutator == "bitflip1") { + return new SliceMutator>(test); + } else if (mutator == "bitflip2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip3") { + return new SliceMutator>(test); + } else if (mutator == "bitflip4") { + return new SliceMutator>(test); + } else if (mutator == "bitflip5") { + return new SliceMutator>(test); + } else if (mutator == "bitflip6") { + return new SliceMutator>(test); + } else if (mutator == "bitflip7") { + return new SliceMutator>(test); + } else if (mutator == "bitflip8") { + return new SliceMutator>(test); + + } else if (mutator == "bitflip2_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip3_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip4_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip5_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip6_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip7_2") { + return new SliceMutator>(test); + } else if (mutator == "bitflip8_2") { + return new SliceMutator>(test); + + } else if (mutator == "bitflip4_4") { + return new SliceMutator>(test); + } else if (mutator == "bitflip6_4") { + return new SliceMutator>(test); + } else if (mutator == "bitflip8_4") { + return new SliceMutator>(test); + + } else if (mutator == "bitflip8_8") { + return new SliceMutator>(test); + + } else if (mutator == "inf_bitflip_random") { + return new InfiniteMutator>(test); + + } else if (mutator == "inf_radamsa_chunked") { + return new InfiniteMutator< + ChunkedSliceMutator>(test); + + } else if (mutator == "inf_radamsa_spliced") { + return new InfiniteMutator< + ChunkedSpliceMutator>(test); + + } else if (mutator == "inf_radamsa_concat") { + return new ConcatMutator(test); + + } else if (mutator == "inf_chunked_repeat") { + return new InfiniteMutator< + ChunkedSliceMutator>(test, 1); + + } else { + return nullptr; + } +} + +#pragma clang diagnostic pop + +} // namespace input +} // namespace granary diff --git a/granary/input/mutate.h b/granary/input/mutate.h new file mode 100644 index 0000000..e21fd7a --- /dev/null +++ b/granary/input/mutate.h @@ -0,0 +1,33 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef LIB_CGC_MUTATE_H_ +#define LIB_CGC_MUTATE_H_ + +#include + +#include "granary/input/record.h" + +namespace granary { +namespace input { + +// Mutator. +class Mutator { + public: + Mutator(const IORecording *record_); + virtual ~Mutator(void); + + std::string RequestMutation(void); + + static Mutator *Create(const IORecording *record, const std::string &mutator); + + protected: + + virtual IORecording *RequestMutationImpl(void) = 0; + + const IORecording *record; +}; + +} // namespace input +} // namespace granary + +#endif // LIB_CGC_MUTATE_H_ diff --git a/granary/input/record.cc b/granary/input/record.cc new file mode 100644 index 0000000..cd425bc --- /dev/null +++ b/granary/input/record.cc @@ -0,0 +1,70 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#include "granary/input/record.h" + +namespace granary { +namespace input { + +IORecording *gRecord = nullptr; + +IORecording::IORecording(void) + : num_inputs(0), + num_input_bytes(0), + num_outputs(0), + num_output_bytes(0) {} + + +void IORecording::AddInput(const std::string &data) { + num_inputs += 1; + num_input_bytes += data.size(); + + IOSystemCall syscall; + syscall.kind = IOKind::kInput; + syscall.data = data; + system_calls.push_back(std::move(syscall)); +} + +void IORecording::AddInput(std::string &&data) { + num_inputs += 1; + num_input_bytes += data.size(); + + IOSystemCall syscall; + syscall.kind = IOKind::kInput; + syscall.data = std::move(data); + system_calls.push_back(std::move(syscall)); +} + +void IORecording::AddOutput(std::string &&data) { + num_outputs += 1; + num_output_bytes += data.size(); + + IOSystemCall syscall; + syscall.kind = IOKind::kOutput; + syscall.data = std::move(data); + system_calls.push_back(std::move(syscall)); +} + +std::string IORecording::ToInput(void) const { + std::string data; + data.reserve(num_input_bytes); + for (const auto &record : system_calls) { + if (IOKind::kInput == record.kind) { + data.insert(data.end(), record.data.begin(), record.data.end()); + } + } + return data; +} + +std::string IORecording::ToOutput(void) const { + std::string data; + data.reserve(num_output_bytes); + for (const auto &record : system_calls) { + if (IOKind::kOutput == record.kind) { + data.insert(data.end(), record.data.begin(), record.data.end()); + } + } + return data; +} + +} // namespace input +} // namespace granary diff --git a/granary/input/record.h b/granary/input/record.h new file mode 100644 index 0000000..3b98c95 --- /dev/null +++ b/granary/input/record.h @@ -0,0 +1,70 @@ +/* Copyright 2016 Peter Goodman (peter@trailofbits.com), all rights reserved. */ + +#ifndef GRANARY_OS_RECORD_H_ +#define GRANARY_OS_RECORD_H_ + +#include +#include + +namespace granary { +namespace input { + +enum class IOKind { + kInvalid, + kInput, + kOutput +}; + +struct IOSystemCall { + inline IOSystemCall(void) + : kind(IOKind::kInvalid) {} + + std::string data; + IOKind kind; +}; + +class IORecording { + public: + IORecording(void); + + size_t num_inputs; + size_t num_input_bytes; + + size_t num_outputs; + size_t num_output_bytes; + + std::vector system_calls; + + typedef std::vector::iterator iterator; + typedef std::vector::const_iterator const_iterator; + + inline iterator begin(void) { + return system_calls.begin(); + } + + inline iterator end(void) { + return system_calls.end(); + } + + inline const_iterator begin(void) const { + return system_calls.begin(); + } + + inline const_iterator end(void) const { + return system_calls.end(); + } + + void AddInput(const std::string &val); + void AddInput(std::string &&val); + void AddOutput(std::string &&val); + + std::string ToInput(void) const; + std::string ToOutput(void) const; +}; + +extern IORecording *gRecord; + +} // namespace input +} // namespace granary + +#endif // GRANARY_OS_RECORD_H_ diff --git a/granary/os/decree_user/decree.h b/granary/os/decree_user/decree.h new file mode 100644 index 0000000..61d2db8 --- /dev/null +++ b/granary/os/decree_user/decree.h @@ -0,0 +1,146 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_DECREE_USER_DECREE_H_ +#define GRANARY_OS_DECREE_USER_DECREE_H_ + +#define DECREE_EBADF 1 +#define DECREE_EFAULT 2 +#define DECREE_EINVAL 3 +#define DECREE_ENOMEM 4 +#define DECREE_ENOSYS 5 +#define DECREE_EPIPE 6 + +#define DECREE_PC eip +#define DECREE_SYSCALL_NR eax +#define DECREE_SYSCALL_RET eax +#define DECREE_SYSCALL_ARG1 ebx +#define DECREE_SYSCALL_ARG2 ecx +#define DECREE_SYSCALL_ARG3 edx +#define DECREE_SYSCALL_ARG4 esi +#define DECREE_SYSCALL_ARG5 edi + +#define DECREE_STDIN 0 +#define DECREE_STDOUT 1 +#define DECREE_STDERR 2 + +#define __NR__terminate 1 +#define __NR_transmit 2 +#define __NR_receive 3 +#define __NR_fdwait 4 +#define __NR_allocate 5 +#define __NR_deallocate 6 +#define __NR_random 7 + +#include "granary/os/process.h" + +namespace granary { +namespace os { + +typedef int32_t decree_fd_mask; + +enum : size_t { + kFdSetSize = 1024, + kNumFdBits = (8 * sizeof(decree_fd_mask)) +}; + +enum : int { + kUsecPerSec = 1000000, + kNsecPerUsec = 1000 +}; + +enum : unsigned { + kSignedSizeMax = 2147483647U +}; + +struct decree_fd_set { + decree_fd_mask _fd_bits[kFdSetSize / kNumFdBits]; +}; + +struct decree_timeval { + int32_t tv_sec; + int32_t tv_usec; +}; + +#define DECREE_FD_SET(b, set) \ + ((set)->_fd_bits[b / _NFDBITS] |= (1 << (b & (_NFDBITS - 1)))) +#define DECREE_FD_CLR(b, set) \ + ((set)->_fd_bits[b / kNumFdBits] &= ~(1 << (b & (kNumFdBits - 1)))) +#define DECREE_FD_ISSET(b, set) \ + ((set)->_fd_bits[b / kNumFdBits] & (1 << (b & (kNumFdBits - 1)))) + +enum class SystemCallSelector { + kInvalid = 0, + kTerminate = 1, + kTransmit = 2, + kReceive = 3, + kFdwait = 4, + kAllocate = 5, + kDeallocate = 6, + kRandom = 7 +}; + +class SystemCallABI { + public: + inline explicit SystemCallABI(os::Process32 *process_) + : process(process_) {} + + // Pointer type. + template ::value,int>::type=0> + inline T Arg(void) const { + auto ptr = static_cast(Arg()); + + // Note: We only look for `nullptr` and not for the entire zero page + // because that could change the `EFAULT`-return behavior of a + // system call by making us avoid trying to read/write from a + // pointer because we know it's null. + if (!ptr) { + return nullptr; + } + + auto base = reinterpret_cast(process->base); + return reinterpret_cast(base + ptr); + } + + void SetReturn(int val) const { + process->regs.eax = static_cast(val); + } + +#define ARG_GETTER(n) \ + template ::value,int>::type=0, \ + typename std::enable_if::type=0> \ + inline T Arg(void) const { \ + return static_cast(process->regs. DECREE_SYSCALL_ARG ## n ); \ + } + + // Assume non-pointer integral type. + ARG_GETTER(1) + ARG_GETTER(2) + ARG_GETTER(3) + ARG_GETTER(4) + ARG_GETTER(5) + +#undef ARG_GETTER + + inline SystemCallSelector Number(void) const { + auto nr = process->regs.DECREE_SYSCALL_NR; + if (__NR__terminate <= nr && __NR_random >= nr) { + return static_cast(nr); + } else { + return SystemCallSelector::kInvalid; + } + } + + os::Process32 *process; + + private: + SystemCallABI(void) = delete; +}; + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_DECREE_USER_DECREE_H_ diff --git a/granary/os/decree_user/snapshot.cc b/granary/os/decree_user/snapshot.cc new file mode 100644 index 0000000..ef6a815 --- /dev/null +++ b/granary/os/decree_user/snapshot.cc @@ -0,0 +1,559 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/snapshot.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "granary/os/process.h" + +DECLARE_string(snapshot_dir); +DECLARE_string(output_snapshot_dir); + +namespace granary { +namespace os { +namespace { +static char gSnapshotPath[128] = {'\0'}; +static char gMem[kPageSize] = {'\0'}; +} // namespace + +// Copy the memory from one process directly into a memory mapped file. +void SnapshotRange(const detail::MappedRange32 &source_range, int source_fd, + int dest_fd) { + auto desired_size = static_cast(source_range.Size()); + for (ssize_t copied_size = 0; copied_size < desired_size; ) { + auto size = std::min(static_cast(desired_size - copied_size), + sizeof gMem); + + GRANARY_IF_ASSERT( errno = 0; ) + lseek64(source_fd, static_cast(source_range.begin) + copied_size, + SEEK_SET); + GRANARY_ASSERT(!errno && "Unable to seek to mapped memory range."); + + GRANARY_IF_ASSERT( errno = 0; ) + auto ret_size = read(source_fd, gMem, size); + if (0 > ret_size) { + if (EAGAIN == errno || EWOULDBLOCK == errno || EINTR == errno) continue; + GRANARY_ASSERT(false && "Failed to read memory for snapshotting."); + } else { + GRANARY_IF_ASSERT( errno = 0; ) + auto write_ret_size = write(dest_fd, gMem, static_cast(ret_size)); + GRANARY_ASSERT(!errno && "Failed to write memory to snapshot."); + copied_size += write_ret_size; + } + } +} + +namespace { +enum { + kMaxNumAttempts = 100 +}; + +// Enable tracing of the target binary. +static void EnableTracing(void) { + for (auto i = 0; i < kMaxNumAttempts; i++) { + if (!ptrace(PTRACE_TRACEME, 0, nullptr, nullptr)) { + raise(SIGSTOP); + return; + } + } + exit(EXIT_FAILURE); +} + +// Wait for system call entry. This will return `false` if we didn't reach the +// expected stopped state. A Failure could mean that the process died or was +// signaled or is looping infinitely. These failure cases should be handled by +// the caller. +static bool WaitForSyscallEntry(pid_t pid) { + for (int i = kMaxNumAttempts, status = 0; i-- > 0; status = 0) { + ptrace(PTRACE_SYSCALL, pid, nullptr, nullptr); + waitpid(pid, &status, 0); + if (WIFSTOPPED(status)) { + if ((SIGTRAP | 0x80) == WSTOPSIG(status)) return true; + } else { + break; + } + } + return false; +} + +// Wait for us to reach the syscall-exit-stop state. This should be called +// after calling `WaitForSyscallEntry`. +static bool WaitForSyscallExit(pid_t pid) { + return WaitForSyscallEntry(pid); +} + +// Attach to the binary and wait for it to raise `SIGSTOP`. +static void TraceBinary(pid_t pid) { + for (int status = 0; !WIFSTOPPED(status); ) { + if (-1 == waitpid(pid, &status, 0)) { + kill(pid, SIGKILL); + exit(EXIT_FAILURE); + } + } + ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACESYSGOOD); +} + +// Copy the register state from a process. +static struct user_regs_struct GetGRegs(pid_t pid) { + struct user_regs_struct regs; + ptrace(PTRACE_GETREGS, pid, NULL, ®s); + regs.rdi = 0; + regs.rsi = 0; + regs.rbp = 0; + regs.rbx = 0; + regs.rdx = 0; + regs.rcx = 0; + regs.rax = 0; + regs.orig_rax = 0; + regs.rsp = 0xbaaaaffcU; + //regs.eip = file->meta.eip; // This is was we really want. + regs.eflags = 0x202; + + return regs; +} + +// Copy the floating-point register state from a process. +static struct user_fpregs_struct GetFPRegs(pid_t pid) { + struct user_fpregs_struct fpregs; + ptrace(PTRACE_GETFPREGS, pid, NULL, &fpregs); + return fpregs; +} + +static size_t GetLine(std::string::iterator &curr, std::string::iterator end, + std::string &line){ + line.clear(); + while (curr != end) { + auto ch = *curr++; + if ('\n' == ch) break; + line.push_back(ch); + } + auto len = line.size(); + line.push_back('\0'); // Lets us use `line.data()` as a cstr. + return len; +} + +static std::string ReadMapsFile(pid_t pid) { + sprintf(gSnapshotPath, "/proc/%d/maps", pid); + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open(gSnapshotPath, O_RDONLY); + GRANARY_ASSERT(!errno && "Unable to open maps file of subprocess."); + + std::string contents; + contents.reserve(kPageSize); + + for (;;) { + auto ret = read(fd, gMem, kPageSize); + if (!ret) break; + if (0 < ret) { + contents.insert(contents.end(), gMem, gMem + ret); + } else { + GRANARY_ASSERT((EAGAIN == errno || EINTR == errno) && + "Could not read memory maps for snapshotting."); + } + } + + return contents; +} + +// Copy the memory address ranges from a process. +static std::vector GetRanges(pid_t pid, AppPC32 eip) { + std::vector ranges; + std::string line; + auto maps_file = ReadMapsFile(pid); + auto file_curr = maps_file.begin(); + auto file_end = maps_file.end(); + while (auto length = GetLine(file_curr, file_end, line)) { + if (22 > length) continue; + + // Things like [stack], [vdso], [vvar], etc. + auto cline = line.data(); + if (strchr(cline, '[') && strchr(cline, ']')) { + if (!strstr(cline, "[heap]")) continue; + } + + if ('-' != cline[8] || ' ' != cline[17] || 'p' != cline[21]) continue; + detail::MappedRange32 range; + memset(&range, 0, sizeof range); + range.is_r = ('r' == cline[18]); + range.is_w = ('w' == cline[19]); + range.is_x = ('x' == cline[20]); + if (2 != sscanf(cline, "%x-%x", &(range.begin), &(range.end))) continue; + range.lazy_begin = range.begin; + + // Auto-split this range in two if it contains the EIP. This is so that we + // can hopefully "pre-split" the binary which typically combines .text + // and .data into one RWX region. + if ((range.begin + kPageSize) <= eip && // Middle-ish of range. + eip < range.end && + kPageSize < (range.end - range.begin)) { + auto old_end = range.end; + range.end = eip & kPageMask; + ranges.push_back(range); + + range.begin = range.end; + range.lazy_begin = range.begin; + range.end = old_end; + } + + ranges.push_back(range); + } + return ranges; +} + +// Open the snapshot file. +static int OpenSnapshotFile(int exe_num, bool create) { + sprintf(gSnapshotPath, "%s/grr.snapshot.%d.persist", + FLAGS_snapshot_dir.c_str(), exe_num); + + auto flags = 0; + auto mode = 0; + if (create) { + flags = O_CREAT | O_TRUNC | O_RDWR | O_LARGEFILE; + mode = 0666; + } else { + flags = O_RDONLY | O_LARGEFILE; + } + + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open(gSnapshotPath, flags, mode); + GRANARY_ASSERT(!errno && "Unable to open the snapshot file."); + + return fd; +} + +static char * const gArgvEnvp[] = {nullptr}; + +// Initialize the snapshot file. +static void InitSnapshotFile(const char *exe_name, int exe_num, int fd) { + if (auto pid = fork()) { + if (-1 == pid) exit(EXIT_FAILURE); + TraceBinary(pid); + + // Walk over the `exec`. + WaitForSyscallEntry(pid); + WaitForSyscallExit(pid); + + // Align the file handle to the end of the file. + GRANARY_IF_ASSERT( errno = 0; ) + ftruncate64(fd, static_cast(sizeof(detail::Snapshot32File))); + GRANARY_ASSERT(!errno && "Unable to scale snapshot file."); + + auto file = new (mmap(nullptr, sizeof(detail::Snapshot32File), + PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) + detail::Snapshot32File; + GRANARY_ASSERT(!errno && "Unable to mmap initial Snapshot32File."); + + // Map the snapshot file into memory. + memset(file, 0, sizeof *file); + + file->meta.magic[0] = 'G'; + file->meta.magic[1] = 'R'; + file->meta.magic[2] = 'R'; + file->meta.magic[3] = 'S'; + file->meta.exe_num = exe_num; + file->meta.gregs = GetGRegs(pid); + file->meta.fpregs = GetFPRegs(pid); + + // Copy the process memory. + auto ranges = GetRanges(pid, static_cast(file->meta.gregs.rip)); + auto size = sizeof(detail::Snapshot32File); + for (const auto &range : ranges) { + size += range.Size(); + } + + sprintf(gSnapshotPath, "/proc/%d/mem", pid); + GRANARY_IF_ASSERT( errno = 0; ) + auto mem_fd = open(gSnapshotPath, O_RDONLY | O_LARGEFILE); + GRANARY_ASSERT(!errno && "Unable to open memory file of subprocess."); + + // For each readable memory range in the process, copy the contents of that + // range into the snapshot file, and copy the range into the snapshot file + // as well. + auto i = 0; + auto snapshot_offset = static_cast(sizeof(detail::Snapshot32File)); + for (const auto &range : ranges) { + if (!range.is_r) { + continue; + } + GRANARY_ASSERT(detail::Snapshot32File::kMaxNumMappedRanges > i); + GRANARY_ASSERT(range.begin == range.lazy_begin); + file->ranges[i] = range; + file->ranges[i].fd_offs = snapshot_offset; + snapshot_offset += range.Size(); + i += 1; + } + + // Initialize the stack range. + GRANARY_ASSERT(detail::Snapshot32File::kMaxNumMappedRanges > i); + file->ranges[i].begin = kStackBegin; + file->ranges[i].end = kStackEnd; + file->ranges[i].lazy_begin = kStackEnd - kMappedStackSize; + file->ranges[i].fd_offs = snapshot_offset; + file->ranges[i].is_r = true; + file->ranges[i].is_w = true; + file->ranges[i].is_x = true; + snapshot_offset += kStackSize; + i += 1; + + // Persist the snapshot file meta-data. + GRANARY_IF_ASSERT( errno = 0; ) + msync(file, sizeof *file, MS_SYNC | MS_INVALIDATE); + munmap(file, sizeof *file); + file = nullptr; + GRANARY_ASSERT(!errno && "Unable to write snapshot meta-data."); + + // Align the file handle to the end of the file. + GRANARY_IF_ASSERT( errno = 0; ) + ftruncate64(fd, static_cast(sizeof(detail::Snapshot32File))); + GRANARY_ASSERT(!errno && "Unable to scale snapshot file (1)"); + + lseek64(fd, 0, SEEK_END); + GRANARY_ASSERT(!errno && "Unable to seek to end of snapshot file (1)"); + + // Copy the memory into the snapshot file. + for (const auto &range : ranges) { + if (!range.is_r) continue; + SnapshotRange(range, mem_fd, fd); + } + + // Add in the stack. + ftruncate64(fd, static_cast(snapshot_offset)); + GRANARY_ASSERT(!errno && "Unable to scale snapshot file (2)"); + + // Add in the magic page. + lseek64(fd, 0, SEEK_END); + GRANARY_ASSERT(!errno && "Unable to seek to end of snapshot file (2)"); + + // Clean up. + close(mem_fd); + kill(pid, SIGKILL); + waitpid(pid, nullptr, WNOHANG); + + } else { + EnableTracing(); + execve(exe_name, gArgvEnvp, gArgvEnvp); + GRANARY_ASSERT(false && "Unable to `exec` process."); + __builtin_unreachable(); + } +} + +static const auto kELFHeader = "\177ELF\x01\x01\x01\x00\x00\x00\x00\x00" + "\x00\x00\x00"; + +enum { + kELFHeaderLen = 15 +}; + +// Creates a copy of a 32-bit CGC program, then changes the program into am +// ELF binary format. +static std::string CopyExecutableFile(const char *exe_path, int exe_num) { + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open(exe_path, O_RDONLY); + GRANARY_ASSERT(!errno && "Executable does not exist."); + + auto new_path = FLAGS_snapshot_dir; + if (new_path.length()) { + new_path += "/"; + } + new_path += ".grr_exe."; + new_path += std::to_string(exe_num); + + auto path = new_path.c_str(); + auto new_fd = open64(path, O_CREAT | O_CLOEXEC | O_RDWR | O_TRUNC, 0777); + GRANARY_ASSERT(!errno && "Could not create copy of the executable."); + + struct stat64 stat; + fstat64(fd, &stat); + GRANARY_ASSERT(!errno && "Could not `fstat` the original executable."); + + write(new_fd, kELFHeader, kELFHeaderLen); + GRANARY_ASSERT(!errno && "Could add header to new executable."); + + off_t after_header_offs = kELFHeaderLen; + sendfile(new_fd, fd, &after_header_offs, + static_cast(stat.st_size - kELFHeaderLen)); + GRANARY_ASSERT(!errno && "Could not copy the original executable."); + + lseek64(new_fd, 0, SEEK_SET); + GRANARY_ASSERT(!errno && "Could not seek to beginning of new executable."); + + // Make ELF binary executable. + fchmod(new_fd, 0777); + GRANARY_ASSERT(!errno && "Could not make ELF binary executable."); + + // Close the old file, and re-open the new file as read-only so that we can + // execute it with `execve`. + close(fd); + close(new_fd); + + return new_path; +} + +} // namespace + +// Revives a snapshot file. +Snapshot32::Snapshot32(int exe_num_) + : fd(OpenSnapshotFile(exe_num_, false)), + exe_num(exe_num_) { + GRANARY_IF_ASSERT( errno = 0; ) + file = reinterpret_cast( + mmap64(nullptr, sizeof(detail::Snapshot32File), + PROT_READ, MAP_POPULATE | MAP_PRIVATE, fd, 0)); + GRANARY_ASSERT(!errno && "Unable to map snapshot file meta-data."); + GRANARY_ASSERT(file->meta.exe_num == exe_num && + "Unexpected executable number in snapshot file meta-data."); +} + +// Creates a snapshot file. +void Snapshot32::Create(const char *exe_name, int exe_num) { + auto exe_path = CopyExecutableFile(exe_name, exe_num); + auto snapshot_fd = OpenSnapshotFile(exe_num, true); + auto exe_path_str = exe_path.c_str(); + InitSnapshotFile(exe_path_str, exe_num, snapshot_fd); + unlink(exe_path_str); +} + +// Creates the snapshot from a process. +void Snapshot32::Create(const Process32 *process) { + + // Size of the snapshot file. + auto size = sizeof(detail::Snapshot32File); + for (const auto &page : process->pages) { + if (PagePerms::kInvalid != page.perms && + PageState::kReserved != page.state) { + size += (page.limit - page.base); + } + } + + std::stringstream temp_snapshot_path_ss; + temp_snapshot_path_ss << FLAGS_output_snapshot_dir << "/.tmp/" + << getpid() << "." << process->Id(); + auto temp_path = temp_snapshot_path_ss.str(); + auto temp_snapshot_path = temp_path.c_str(); + + GRANARY_IF_ASSERT( errno = 0; ) + auto fd = open64(temp_snapshot_path, + O_CREAT | O_CLOEXEC | O_RDWR | O_TRUNC, 0666); + GRANARY_ASSERT(!errno && "Unable to create snapshot file."); + + ftruncate64(fd, static_cast(size)); + GRANARY_ASSERT(!errno && "Unable to scale snapshot file."); + + auto file = reinterpret_cast( + mmap64(nullptr, size, + PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); + GRANARY_ASSERT(!errno && "Unable to map snapshot file meta-data."); + + file->meta.magic[0] = 'G'; + file->meta.magic[1] = 'R'; + file->meta.magic[2] = 'R'; + file->meta.magic[3] = 'S'; + file->meta.exe_num = process->Id(); + file->meta.gregs.rdi = process->regs.edi; + file->meta.gregs.rsi = process->regs.esi; + file->meta.gregs.rbp = process->regs.ebp; + file->meta.gregs.rbx = process->regs.ebx; + file->meta.gregs.rdx = process->regs.edx; + file->meta.gregs.rcx = process->regs.ecx; + file->meta.gregs.rax = process->regs.eax; + file->meta.gregs.rsp = process->regs.esp; + file->meta.gregs.rip = process->regs.eip - 2; /* Size of INT 0x80 */ + file->meta.gregs.eflags = process->regs.eflags; + file->meta.fpregs = process->fpregs; + + auto i = 0; + auto offset = static_cast(sizeof(detail::Snapshot32File)); + auto data = reinterpret_cast(file); + + for (const auto &page : process->pages) { + if (PagePerms::kInvalid == page.perms || + PageState::kReserved == page.state || + !(page.limit - page.base)) { + continue; + } + + auto &range = file->ranges[i++]; + auto range_size = page.limit - page.base; + + range.begin = page.base; + range.end = page.limit; + range.lazy_begin = page.lazy_base; + range.fd_offs = offset; + + switch (page.perms) { + case PagePerms::kInvalid: break; + case PagePerms::kRO: + range.is_r = true; + break; + case PagePerms::kRW: + range.is_r = true; + range.is_w = true; + break; + case PagePerms::kRWX: + range.is_r = true; + range.is_w = true; + range.is_x = true; + break; + case PagePerms::kRX: + range.is_r = true; + range.is_x = true; + break; + } + + GRANARY_ASSERT(static_cast(offset) < size && + "Invalid snapshot file size."); + + auto lazy_offset = page.lazy_base - page.base; + + for (Addr32 j = 0; j < lazy_offset; ++j) { + data[offset + j] = 0; + } + + for (Addr32 a = page.lazy_base, o = 0; a < page.limit; ++a, ++o) { + auto b = reinterpret_cast(process->base) + a; + data[offset + lazy_offset + o] = *b; + } + + offset += range_size; + } + + GRANARY_ASSERT(static_cast(offset) == size && + "Invalid snapshot file size."); + + msync(data, size, MS_SYNC | MS_INVALIDATE); + GRANARY_ASSERT(!errno && "Couldn't sync snapshot file (1)."); + fsync(fd); + GRANARY_ASSERT(!errno && "Couldn't sync snapshot file (2)."); + close(fd); + GRANARY_ASSERT(!errno && "Couldn't close snapshot file."); + + std::stringstream snapshot_path_ss; + snapshot_path_ss << FLAGS_output_snapshot_dir << "/grr.snapshot." + << process->Id() << ".persist"; + + auto path = snapshot_path_ss.str(); + rename(temp_path.c_str(), path.c_str()); + GRANARY_ASSERT(!errno && "Couldn't commit to snapshot file."); +} + +} // namespace os +} // namespace granary diff --git a/granary/os/decree_user/syscall.cc b/granary/os/decree_user/syscall.cc new file mode 100644 index 0000000..fae0de3 --- /dev/null +++ b/granary/os/decree_user/syscall.cc @@ -0,0 +1,696 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/base/base.h" + +#include "granary/input/record.h" + +#include "granary/os/syscall.h" +#include "granary/os/file.h" +#include "granary/os/process.h" +#include "granary/os/snapshot.h" +#include "granary/os/decree_user/decree.h" + +#include + +#include + + +DEFINE_bool(strace, false, "Enable printing of system call traces."); + +DECLARE_int32(num_exe); +DECLARE_string(output_snapshot_dir); +DECLARE_int32(snapshot_before_input_byte); + +namespace granary { + +extern std::string gInput; +extern "C" size_t gInputIndex; + +namespace os { + +namespace { + +// Implements undefined system calls. +static SystemCallStatus BadSystemCall(SystemCallABI abi) { + abi.SetReturn(DECREE_ENOSYS); + return SystemCallStatus::kComplete; +} + +// Implements the terminate system call. +static SystemCallStatus Terminate(const Process32 *process, SystemCallABI abi) { + if (!FLAGS_output_snapshot_dir.empty()) { + Snapshot32::Create(process); + return SystemCallStatus::kTerminated; + } + + abi.SetReturn(0); + GRANARY_STRACE( std::cerr << process->pid << " terminate status=" + << abi.Arg<1>() << std::endl; ); + GRANARY_UNUSED(process); + return SystemCallStatus::kTerminated; +} + +// Converts a `FileIOStatus` into a `SystemCallStatus`. +static SystemCallStatus ConvertStatus(SystemCallABI abi, FileIOStatus status) { + switch (status) { + case FileIOStatus::kCompleted: + GRANARY_STRACE( std::cerr << std::endl; ) + abi.SetReturn(0); + return SystemCallStatus::kComplete; + + case FileIOStatus::kFaulted: + GRANARY_STRACE( std::cerr << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + + case FileIOStatus::kInProgress: + GRANARY_STRACE( std::cerr << "(IPR)" << std::endl; ) + return SystemCallStatus::kInProgress; + } +} + + +enum : size_t { + kMaxTrailingEmptyReceives = 2ULL, +}; + +// Implement writing to standard output of `data` by `process`. +uint32_t DoTransmit(os::Process32 *process, int fd, const uint8_t *data, + uint32_t count) { + GRANARY_UNUSED(process); + GRANARY_UNUSED(fd); + + if (count && input::gRecord) { + std::string syscall_data; + syscall_data.reserve(count); + syscall_data.insert(syscall_data.begin(), data, data + count); + input::gRecord->AddOutput(std::move(syscall_data)); + } + return count; +} + +// Implement reading by `process` of standard input to `data`. +static uint32_t DoReceive(os::Process32 *process, int fd, uint8_t *data, + uint32_t count, bool &faulted) { + GRANARY_UNUSED(fd); + + faulted = false; + + // Don't need to log this. + if (!count) { + return 0; + } + + std::string recorded_input; + recorded_input.reserve(count); + + size_t max_input_len = 0; + char last_ch = '\0'; + + for (auto i = 0ULL; i < count; ++i) { + auto index = gInputIndex++; + if (index >= gInput.size()) { + + // Walked too far off the end of the input. + if ((index - gInput.size()) >= kMaxTrailingEmptyReceives) { + GRANARY_DEBUG( std::cerr << "; DONE REPLAY" << std::endl; ) + NonMaskableInterrupt(); + + } else { + return 0; + } + } + + auto ch = gInput[index]; + last_ch = ch; + + if (process->TryWrite(data + i, ch)) { + ++max_input_len; + recorded_input.append(1, ch); + + // Faulted during the `receive`. + } else { + faulted = true; + break; + } + } + + if (faulted) { + recorded_input.append(1, last_ch); // To force the fault in a replay. + } + + if (input::gRecord) { + input::gRecord->AddInput(std::move(recorded_input)); + } + + return static_cast(max_input_len); +} + + +// Implement generation of `count` random bytes of data into `data`. +static void DoRandom(os::Process32 *process, uint8_t *data, uint32_t count) { + for (auto i = 0U; i < count; i++) { + if (!process->TryWrite(data, 0)) { + GRANARY_ASSERT(false && "Should be able to write `count` random bytes."); + } + } +} + +enum { + kLinuxArbitraryMinumumEscapeSize = 2048U // Found by trial and error.. WTF? +}; + +// Counts the number of readable bytes in a range. +static uint32_t CountChunkedReadableBytes(Process32 *process, uint8_t *buf, + uint32_t length) { + auto i = 0U; + for (auto chunk = 0U; chunk < length; ) { + auto next_chunk = chunk + kLinuxArbitraryMinumumEscapeSize; + for (; i < length && i < next_chunk; ++i) { + uint8_t val = 0; + if (!process->TryRead(&(buf[i]), val)) return chunk; + } + chunk = next_chunk; + } + return i; +} + +// Implements the `transmit` DECREE system call. +static SystemCallStatus Transmit(Process32 *process, + FileTable &files, + SystemCallABI abi) { + if (!FLAGS_output_snapshot_dir.empty() && + !FLAGS_snapshot_before_input_byte) { + Snapshot32::Create(process); + return SystemCallStatus::kTerminated; + } + + const auto fd = abi.Arg<1>(); + const auto buf = abi.Arg<2,uint8_t *>(); + const auto length = abi.Arg<3,uint32_t>(); + const auto tx_bytes = abi.Arg<4,uint32_t *>(); + const auto num_fds = static_cast(files.size()); + + GRANARY_STRACE( std::cerr << process->Id() << " transmit length=" << length + << " fd=" << fd + << " buf=0x" << std::hex << (abi.Arg<2,uint32_t>()) + << " tx_bytes=0x" << std::hex + << (abi.Arg<4,uint32_t>()) << std::dec << " -> "; ) + + // Figure out how much to send. Linux seems to have this weird minimum + // amount of bytes that can escape before it will EFAULT, so we'll respect + // that. + auto num_bytes = length; + if (num_bytes) { + num_bytes = CountChunkedReadableBytes(process, buf, length); + if (!num_bytes) { + GRANARY_STRACE( std::cerr << "EFAULT (buf)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + } + } + + if (DECREE_STDIN == fd || DECREE_STDOUT == fd || DECREE_STDERR == fd) { + if (num_bytes && DECREE_STDERR != fd) { + num_bytes = DoTransmit(process, fd, buf, num_bytes); + } + if (tx_bytes && !process->TryWrite(tx_bytes, num_bytes)) { + GRANARY_STRACE( std::cerr << "EFAULT (tx_bytes)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + } else { + GRANARY_STRACE( std::cerr << "length=" << num_bytes << std::endl; ) + abi.SetReturn(0); + } + return SystemCallStatus::kComplete; + + // Invalid FD. + // TODO(pag): It seems like `num_fds` and `num_fds+1` might actually + // alias STDIN/STDOUT in `cb-server`. Double check this. + } else if (0 > fd || fd >= num_fds) { + GRANARY_STRACE( std::cerr << "EBADF (fd)" << std::endl; ) + abi.SetReturn(DECREE_EBADF); + return SystemCallStatus::kComplete; + + // For non-STDIN/STDOUT/STDERR, the chunking behavior doesn't apply. + } else if (num_bytes < length) { + GRANARY_STRACE( std::cerr << "EFAULT (buf)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + + // Okay we can do this. + } else { + auto file = files[static_cast(fd)]; + auto status = ConvertStatus( + abi, file->Write(process, tx_bytes, buf, num_bytes, fd)); + GRANARY_STRACE( std::cerr << std::endl; ) + return status; + } +} + +// Implements the `receive` DECREE system call. +static SystemCallStatus Receive(Process32 *process, + FileTable &files, + SystemCallABI abi) { + + + const auto fd = abi.Arg<1>(); + const auto buf = abi.Arg<2,uint8_t *>(); + const auto length = abi.Arg<3,uint32_t>(); + const auto rx_bytes = abi.Arg<4,uint32_t *>(); + const auto num_fds = static_cast(files.size()); + + // If we're not counting down to a specific number of receives, then + // `FLAGS_snapshot_after_num_receives` will be zero, so we'll snapshot + // right away. However, if we are, then we don't want to trigger snapshotting + // in non-`receive` syscalls, so we check against `1` and make sure that + // the zero check is never triggered. + if (!FLAGS_output_snapshot_dir.empty()) { + auto max_byte_index = static_cast(FLAGS_snapshot_before_input_byte); + if ((gInputIndex + length) >= max_byte_index) { + Snapshot32::Create(process); + return SystemCallStatus::kTerminated; + } + } + + if (FLAGS_snapshot_before_input_byte) { + FLAGS_snapshot_before_input_byte -= 1; + } + GRANARY_STRACE( std::cerr << process->Id() << " receive length=" << length + << " fd=" << fd + << " buf=0x" << std::hex << abi.Arg<2,Addr32>() + << " rx_bytes=0x" << std::hex << abi.Arg<4,Addr32>() + << std::dec << " -> "; ) + + if (DECREE_STDIN == fd || DECREE_STDOUT == fd || DECREE_STDERR == fd) { + auto receive_fault = false; + auto num_bytes = DoReceive(process, fd, buf, length, receive_fault); + + GRANARY_STRACE(std::cerr << "length=" << num_bytes; ) + + // We faulted when receiving data, but we got some data, but didn't update + // the count. + if (receive_fault) { + abi.SetReturn(DECREE_EFAULT); + GRANARY_STRACE( std::cerr << " EFAULT (buf)"; ) + + // Try to update the number of bytes read, regardless of if we detected + // an EFAULT. + } else if (rx_bytes && !process->TryWrite(rx_bytes, num_bytes)) { + GRANARY_STRACE( std::cerr << "EFAULT (rx_bytes)"; ) + abi.SetReturn(DECREE_EFAULT); + + } else { + abi.SetReturn(0); + } + + GRANARY_STRACE( std::cerr << std::endl; ) + + return SystemCallStatus::kComplete; + + // Invalid FD. + // TODO(pag): It seems like `num_fds` and `num_fds+1` might actually + // alias STDIN/STDOUT in `cb-server`. Double check this. + } else if (0 > fd || fd >= num_fds) { + GRANARY_STRACE( std::cerr << "EBADF (fd)" << std::endl; ) + abi.SetReturn(DECREE_EBADF); + return SystemCallStatus::kComplete; + + // Okay we can do this. + } else { + auto file = files[static_cast(fd)]; + auto status = ConvertStatus( + abi, file->Read(process, rx_bytes, buf, length, fd)); + GRANARY_STRACE( std::cerr << std::endl; ) + return status; + } +} + +enum PageCheckType { + kCheckPageReadable, + kCheckPageWritable +}; + +// Checks whether pages are readable/writable. +// +// In the case of `Receive` on stdin: We can't just pass `buf` to a `read` +// system call and depend on its `EFAULT` behavior because we might be reading +// into an RWX page in the RX state (which should convert that page into the +// RW state and invalidate the page hash). +static bool CheckPages(Process32 *process, uint8_t *buf, size_t length, + PageCheckType check) { + auto buf_addr = reinterpret_cast(buf); + auto buf_limit = buf_addr + length; + auto buf_base = buf_addr & kPageMask; + if (!buf_base) return false; + auto buf_str = reinterpret_cast(buf_base); + for (; buf_base < buf_limit; ) { + uint8_t byte; + if (!process->TryRead(buf_str, byte)) return false; + if (kCheckPageWritable == check && !process->TryWrite(buf_str, byte)) { + return false; + } + buf_base += kPageSize; + buf_str += kPageSize; + } + return true; +} + +// Checks whether or not a `decree_timeval` struct is valid. +static bool CheckTimeout(Process32 *process, SystemCallABI abi, + const decree_timeval *timeout) { + if (!timeout) return true; + + decree_timeval to = {0, 0}; + if (!process->TryRead(timeout, to)) { + GRANARY_STRACE( std::cerr << "EFAULT (timeout)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return false; + } + + GRANARY_STRACE( std::cerr << "timeout=[s=" << to.tv_sec << " us=" + << to.tv_usec << "] "; ) + + if (0 > to.tv_sec || 0 > to.tv_usec) { + GRANARY_STRACE( std::cerr << "EINVAL (timeout)" << std::endl; ) + abi.SetReturn(DECREE_EINVAL); + return false; + } + return true; +} + +// Updates a FD set. Returns `false` if an invalid descriptor is referenced. +static bool UpdateSet(const FileTable &files, + bool (File::*will_block)(const Process32 *) const, + const Process32 *proc, decree_fd_set *set, int nfds, + int32_t *count, bool is_read) { + auto max_fds = sizeof(decree_fd_set) * 8; + auto max_fd = static_cast(nfds); + for (auto fd = 0UL; fd < max_fds; ++fd) { + if (DECREE_FD_ISSET(fd, set)) { + if (fd >= max_fd) return false; + if (3 <= fd && (files[fd]->*will_block)(proc)) { + DECREE_FD_CLR(fd, set); + + } else { + if (is_read && 2 > fd && gInputIndex >= gInput.size()) { + DECREE_FD_CLR(fd, set); + + } else { + ++*count; + } + } + } + } + return true; +} + +// Print out an FD set. +static void PrintSet(const decree_fd_set *set, const char *name, int nfds) { + GRANARY_STRACE( std::cerr << name << "=["; ) + auto max_fds = sizeof(decree_fd_set) * 8; + auto max_fd = static_cast(nfds); + const char *sep = ""; + for (auto fd = 0UL; fd < max_fds; ++fd) { + if (fd >= max_fd) break; + if (DECREE_FD_ISSET(fd, set)) { + GRANARY_STRACE( std::cerr << sep << fd; ) + sep = ","; + } + } + GRANARY_STRACE( std::cerr << "]"; ) +} + +// Implements the `fdwait` DECREE system call. +static SystemCallStatus Fdwait(Process32 *process, + FileTable &files, + SystemCallABI abi) { +// if (!FLAGS_output_snapshot_dir.empty() && +// !FLAGS_snapshot_before_input_byte) { +// Snapshot32::Create(process); +// return SystemCallStatus::kTerminated; +// } + + auto nfds = abi.Arg<1>(); + auto readfds = abi.Arg<2,decree_fd_set *>(); + auto writefds = abi.Arg<3,decree_fd_set *>(); + auto timeout = abi.Arg<4,const decree_timeval *>(); + auto readyfds = abi.Arg<5,int32_t *>(); + + GRANARY_STRACE( std::cerr << process->Id() << " fdwait nfds=" << nfds + << " readfds=0x" << std::hex << abi.Arg<2,Addr32>() + << " writefds=0x" << std::hex << abi.Arg<3,Addr32>() + << " timeout=0x" << std::hex << abi.Arg<4,Addr32>() + << " readyfds=0x" << std::hex << abi.Arg<5,Addr32>() + << std::dec << " -> "; ) + + if (!CheckTimeout(process, abi, timeout)) { + return SystemCallStatus::kComplete; + } + + if (0 > nfds) { + GRANARY_STRACE( std::cerr << "EINVAL (nfds)" << std::endl; ) + abi.SetReturn(DECREE_EINVAL); + return SystemCallStatus::kComplete; + } + + if (readfds && !CheckPages(process, abi.Arg<2,uint8_t *>(), + sizeof *readfds, kCheckPageWritable)) { + GRANARY_STRACE( std::cerr << "EFAULT (readfds)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + } + + if (writefds && !CheckPages(process, abi.Arg<3,uint8_t *>(), + sizeof *writefds, kCheckPageWritable)) { + GRANARY_STRACE( std::cerr << "EFAULT (writefds)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + } + + auto num_bits = 0; + nfds = std::min(nfds, FLAGS_num_exe * 2 + 1); + decree_fd_set read_fd_set; + decree_fd_set write_fd_set; + + if (readfds) { + memcpy(&read_fd_set, readfds, sizeof(decree_fd_set)); + } + + if (writefds) { + memcpy(&write_fd_set, writefds, sizeof(decree_fd_set)); + } + + if (readfds && + !UpdateSet(files, &File::ReadWillBlock, + process, &read_fd_set, nfds, &num_bits, true)) { + GRANARY_STRACE( std::cerr << "EBADF (readfds)" << std::endl; ) + abi.SetReturn(DECREE_EBADF); + return SystemCallStatus::kComplete; + } + + if (writefds && + !UpdateSet(files, &File::WriteWillBlock, + process, &write_fd_set, nfds, &num_bits, false)) { + GRANARY_STRACE( std::cerr << "EBADF (writefds)" << std::endl; ) + abi.SetReturn(DECREE_EBADF); + return SystemCallStatus::kComplete; + } + + if (readyfds && !process->TryWrite(readyfds, num_bits)) { + GRANARY_STRACE( std::cerr << "EFAULT (readyfds)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + } + + if (!num_bits) { + if (!timeout) { + GRANARY_STRACE( std::cerr << "(IPR)" << std::endl; ) + return SystemCallStatus::kInProgress; + } + + if (timeout && (timeout->tv_sec || timeout->tv_usec)) { + if (-1 == process->schedule_delay) { + if (!(process->schedule_delay = timeout->tv_sec)) { + process->schedule_delay = 1; // Because `timeout->tv_usec != 0`. + } + GRANARY_STRACE( std::cerr << "(IPR)" << std::endl; ) + return SystemCallStatus::kSleeping; + } else if (process->schedule_delay--) { + GRANARY_STRACE( std::cerr << "(IPR)" << std::endl; ) + return SystemCallStatus::kSleeping; + } else { + process->schedule_delay = -1; + } + } + } + + GRANARY_STRACE( std::cerr << "nfds=" << num_bits;) + + if (readfds) { + PrintSet(&read_fd_set, " readfds", nfds); + memcpy(readfds, &read_fd_set, sizeof(decree_fd_set)); + } + + if (writefds) { + PrintSet(&write_fd_set, " writefds", nfds); + memcpy(writefds, &write_fd_set, sizeof(decree_fd_set)); + } + + GRANARY_STRACE( std::cerr << std::endl; ) + + abi.SetReturn(0); + return SystemCallStatus::kComplete; +} + +enum : uint32_t { + k1GiB = 1UL << 30 +}; + +// Implements the `allocate` DECREE system call. +static SystemCallStatus Allocate(Process32 *process, SystemCallABI abi) { + auto length = abi.Arg<1,uint32_t>(); + auto is_executable = 0 != abi.Arg<2>(); + auto addr = abi.Arg<3,Addr32 *>(); + + GRANARY_STRACE( std::cerr << process->Id() << " allocate length=0x" + << std::hex << length << std::dec << " is_x=" + << is_executable << " addr=0x" << std::hex + << abi.Arg<3,Addr32>() << std::dec + << " -> "; ) + + if (!length) { + GRANARY_STRACE( std::cerr << "EINVAL" << std::endl; ) + abi.SetReturn(DECREE_EINVAL); + return SystemCallStatus::kComplete; + } + + // Round up to nearest page size. + auto num_bytes = (length + os::kPageSize - 1UL) & os::kPageMask; + auto perms = is_executable ? PagePerms::kRWX : PagePerms::kRW; + auto addr32 = process->Allocate(num_bytes, perms); + + abi.SetReturn(0); + + if (!addr32) { + GRANARY_STRACE( std::cerr << "ENOMEM" << std::endl; ) + abi.SetReturn(DECREE_ENOMEM); + return SystemCallStatus::kComplete; + + } else if (addr && !process->TryWrite(addr, addr32)) { + GRANARY_STRACE( std::cerr << "EFAULT" << std::endl; ) + process->Deallocate(addr32, num_bytes); + abi.SetReturn(DECREE_EFAULT); + + } else { + GRANARY_STRACE( std::cerr << "0x" << std::hex << addr32 + << std::dec << std::endl; ) + } + + return SystemCallStatus::kComplete; +} + +// Implements the `allocate` DECREE system call. +static SystemCallStatus Deallocate(Process32 *process, SystemCallABI abi) { + auto addr = abi.Arg<1,Addr32>(); + auto addr_uint = static_cast(addr); + auto length = abi.Arg<2,uint32_t>(); + + GRANARY_STRACE( std::cerr << process->Id() << " deallocate " + << "addr=0x" << std::hex << addr + << " length=0x" << std::hex << length + << std::dec << " -> "; ) + + auto aligned_length = (length + os::kPageSize - 1UL) & os::kPageMask; + + if (!aligned_length) { + abi.SetReturn(DECREE_EINVAL); + GRANARY_STRACE( std::cerr << "EINVAL (length)" << std::endl; ) + + } else if (addr_uint != (addr_uint & kPageMask)) { + abi.SetReturn(DECREE_EINVAL); + GRANARY_STRACE( std::cerr << "EINVAL (addr)" << std::endl; ) + + } else if (addr_uint >= kTaskSize) { + abi.SetReturn(DECREE_EINVAL); + GRANARY_STRACE( std::cerr << "EINVAL (addr > task size)" << std::endl; ) + + // Checks for possible overflow. + } else if (length > (kTaskSize - addr_uint)) { + abi.SetReturn(DECREE_EINVAL); + GRANARY_STRACE( std::cerr << "EINVAL (addr > task size)" << std::endl; ) + + } else { + process->Deallocate(addr, aligned_length); + abi.SetReturn(0); + GRANARY_STRACE( std::cerr << "0" << std::endl; ) + } + + return SystemCallStatus::kComplete; +} + +// Implements the `random` system call. +static SystemCallStatus Random(Process32 *process, SystemCallABI abi) { +// if (!FLAGS_output_snapshot_dir.empty() && +// !FLAGS_snapshot_before_input_byte) { +// Snapshot32::Create(process); +// return SystemCallStatus::kTerminated; +// } + + auto buf = abi.Arg<1,uint8_t *>(); + auto count = abi.Arg<2,uint32_t>(); + auto rnd_bytes = abi.Arg<3,uint32_t *>(); + + GRANARY_STRACE( std::cerr << process->Id() << " random" + << " buf=" << std::hex << abi.Arg<1,Addr32>() + << " count=" << std::dec << count + << " rnd_bytes=" << std::hex << abi.Arg<3,Addr32>() + << std::dec; ) + + abi.SetReturn(0); + + if (count) { + if (count > kSignedSizeMax) { + GRANARY_STRACE( std::cerr << " -> EINVAL (count too big)" << std::endl; ) + abi.SetReturn(DECREE_EINVAL); + return SystemCallStatus::kComplete; + } + + if (!buf || !CheckPages(process, buf, count, kCheckPageWritable)) { + GRANARY_STRACE( std::cerr << " -> EFAULT (buf)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + return SystemCallStatus::kComplete; + } + } + + if (count) { + DoRandom(process, buf, count); + } + GRANARY_STRACE( std::cerr << " -> count=" << count << std::endl; ) + + if (rnd_bytes && !process->TryWrite(rnd_bytes, count)) { + GRANARY_STRACE( std::cerr << " EFAULT (rnd_bytes)" << std::endl; ) + abi.SetReturn(DECREE_EFAULT); + } + + return SystemCallStatus::kComplete; +} + +} // namespace + +// Handles system calls. +SystemCallStatus SystemCall(Process32 *process, FileTable &files) { + SystemCallABI abi{process}; + switch (abi.Number()) { + case SystemCallSelector::kInvalid: return BadSystemCall(abi); + case SystemCallSelector::kTerminate: return Terminate(process, abi); + case SystemCallSelector::kTransmit: return Transmit(process, files, abi); + case SystemCallSelector::kReceive: return Receive(process, files, abi); + case SystemCallSelector::kFdwait: return Fdwait(process, files, abi); + case SystemCallSelector::kAllocate: return Allocate(process, abi); + case SystemCallSelector::kDeallocate: return Deallocate(process, abi); + case SystemCallSelector::kRandom: return Random(process, abi); + } +} + +} // namespace os +} // namespace granary diff --git a/granary/os/file.cc b/granary/os/file.cc new file mode 100644 index 0000000..b26c819 --- /dev/null +++ b/granary/os/file.cc @@ -0,0 +1,133 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/file.h" + +#include "granary/os/process.h" + +#include + +#include + +DECLARE_bool(strace); + +namespace granary { +namespace os { + +File::File(void) { + memset(this, 0, sizeof *this); +} + +// Emulated behavior: +// - Readers can under read. +// - Writers block if their write exceeds the max buffer size. +// - Writers block if the write would case the buffer to fill. + +// Read from this file. +FileIOStatus File::Read(Process32 *process, uint32_t *num_bytes, + uint8_t *buf, uint32_t count, int fd) { + GRANARY_UNUSED(fd); + auto status = FileIOStatus::kCompleted; + auto completed_count = 0U; + if (count) { + if (blocked_reader) { + // Someone else is at the head of the queue. + if (process != blocked_reader) { + return FileIOStatus::kInProgress; + + // We're the blocked reader, and no new data is available. + } else if (reader_head == writer_head) { + return FileIOStatus::kInProgress; + + } else { + blocked_reader = nullptr; + } + + // We want to read, but no data is available. + } else if (reader_head == writer_head) { + blocked_reader = process; + return FileIOStatus::kInProgress; + } + + auto max_count = std::min(writer_head - reader_head, count); + for (; completed_count < max_count; ++completed_count) { + auto read_val = buffer[(reader_head + completed_count) % kBufferSize]; + if (!process->TryWrite(buf + completed_count, read_val)) { + status = FileIOStatus::kFaulted; + break; + } + } + reader_head += completed_count; + } + + GRANARY_STRACE( std::cerr << "length=" << completed_count; ) + if (FileIOStatus::kFaulted == status) { + GRANARY_STRACE( std::cerr << " EFAULT (buf)"; ) + } else if (num_bytes && !process->TryWrite(num_bytes, completed_count)) { + GRANARY_STRACE( std::cerr << " EFAULT (rx_bytes)"; ) + status = FileIOStatus::kFaulted; + } + + return status; +} + +// Write to this file. +FileIOStatus File::Write(Process32 *process, uint32_t *num_bytes, + uint8_t *buf, uint32_t count, int fd) { + GRANARY_UNUSED(fd); + auto status = FileIOStatus::kCompleted; + auto completed_count = 0U; + if (count) { + if (blocked_writer) { + // Someone else is at the head of the queue. + if (process != blocked_writer) { + return FileIOStatus::kInProgress; + + // We're the blocked writer, and the buffer is still too full. + } else if ((writer_head - reader_head + count) > kBufferSize) { + return FileIOStatus::kInProgress; + + } else { + blocked_writer_count = 0; + blocked_writer = nullptr; + } + + // We want to write, but the buffer is too full. + } else if ((writer_head - reader_head + count) > kBufferSize) { + blocked_writer = process; + blocked_writer_count = count; + return FileIOStatus::kInProgress; + } + + for (; completed_count < count; ++completed_count) { + auto &write_val = buffer[(writer_head + completed_count) % kBufferSize]; + if (!process->TryRead(buf + completed_count, write_val)) { + status = FileIOStatus::kFaulted; + break; + } + } + writer_head += completed_count; + } + + GRANARY_STRACE( std::cerr << "length=" << completed_count; ) + if (FileIOStatus::kFaulted == status) { + GRANARY_STRACE( std::cerr << " EFAULT (buf)"; ) + } else if (num_bytes && !process->TryWrite(num_bytes, completed_count)) { + GRANARY_STRACE( std::cerr << " EFAULT (tx_bytes)"; ) + status = FileIOStatus::kFaulted; + } + + return status; +} + +bool File::ReadWillBlock(const Process32 *process) const { + return reader_head == writer_head || + (blocked_reader && blocked_reader != process); +} + +bool File::WriteWillBlock(const Process32 *process) const { + return ((writer_head - reader_head + blocked_writer_count) > kBufferSize) || + (blocked_writer && blocked_writer != process); +} + +} // namespace os +} // namespace granary diff --git a/granary/os/file.h b/granary/os/file.h new file mode 100644 index 0000000..93aa093 --- /dev/null +++ b/granary/os/file.h @@ -0,0 +1,61 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_FILE_H_ +#define GRANARY_OS_FILE_H_ + +#include "granary/os/page.h" + +#include + +namespace granary { +namespace os { + +class Process32; + +enum class FileIOStatus { + kCompleted, // The I/O operation completed. + kFaulted, // The I/O operation failed due to an access violation. + + // The operation is in-progress. The operation must be repeated in order to + // figure out if it succeeded, failed, or remains in progress. + kInProgress +}; + +class File { + public: + File(void); + File(const File &) = default; + + // Read from this file. + FileIOStatus Read(Process32 *process, uint32_t *num_bytes, + uint8_t *buf, uint32_t count, int fd); + + // Write to this file. + FileIOStatus Write(Process32 *process, uint32_t *num_bytes, + uint8_t *buf, uint32_t count, int fd); + + bool ReadWillBlock(const Process32 *process) const; + bool WriteWillBlock(const Process32 *process) const; + + void Cancel(void); + + enum : size_t { + kBufferSize = kPageSize * 46UL // Via trial and error. + }; + + private: + uint8_t buffer[kBufferSize]; + size_t writer_head; + size_t reader_head; + + uint32_t blocked_writer_count; + Process32 *blocked_writer; + Process32 *blocked_reader; +}; + +typedef std::vector FileTable; + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_FILE_H_ diff --git a/granary/os/page.h b/granary/os/page.h new file mode 100644 index 0000000..af8aa63 --- /dev/null +++ b/granary/os/page.h @@ -0,0 +1,63 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_PAGE_H_ +#define GRANARY_OS_PAGE_H_ + +#include "granary/base/base.h" + +#include + +namespace granary { +namespace os { +enum : uintptr_t { + kPageSize = 4096ULL, + kPageMask = ~4095ULL +}; + +enum : uintptr_t { + k1GiB = 1ULL << 30ULL, + kProcessSize = k1GiB * 4ULL, + k1MiB = 1048576, + kStackSize = 8 * k1MiB, + kMappedStackSize = 2 * k1MiB, + kStackLimitPage = 0xbaaaa000U, + kStackEnd = kStackLimitPage + kPageSize, + kStackBegin = kStackEnd - kStackSize, + kMaxAddress = 0xB8000000U, + kReserveNumRanges = 32UL, + kTaskSize = 0xFFFFe000U +}; + +enum class PageState : uint8_t { + kReserved, + kRO, + kRW, + kRX +}; + +enum class PagePerms : uint8_t { + kInvalid, + kRO, + kRW, + kRWX, + kRX +}; + +struct PageRange32 { + Addr32 base; + Addr32 limit; + Addr32 lazy_base; + PagePerms perms; + mutable PageState state; + mutable bool hash_is_valid; + mutable uint32_t hash; + + inline bool operator<(const PageRange32 &that) const { + return base > that.base; + } +}; + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_PAGE_H_ diff --git a/granary/os/process.cc b/granary/os/process.cc new file mode 100644 index 0000000..3082593 --- /dev/null +++ b/granary/os/process.cc @@ -0,0 +1,551 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/process.h" +#include "granary/os/snapshot.h" + +#include +#include + +#include + +#include +#include "../../third_party/xxhash/xxhash.h" + +namespace granary { +namespace os { + +// The current thread for this process. +GRANARY_THREAD_LOCAL(Process32 *) gProcess = nullptr; + +namespace { + +// Return the beginning page state associated with the page permissions. +PageState BeginState(PagePerms perms) { + switch (perms) { + case PagePerms::kInvalid: return PageState::kReserved; + case PagePerms::kRO: return PageState::kRO; + case PagePerms::kRW: return PageState::kRW; + case PagePerms::kRWX: return PageState::kRW; + case PagePerms::kRX: return PageState::kRX; + } +} + +// Convert a `PagePerms` into protection flags for `mmap`. +int PermsToProt(PagePerms perms) { + switch (perms) { + case PagePerms::kInvalid: return PROT_NONE; + case PagePerms::kRO: return PROT_READ; + case PagePerms::kRW: return PROT_READ | PROT_WRITE; + case PagePerms::kRWX: return PROT_READ | PROT_WRITE; + case PagePerms::kRX: return PROT_READ | PROT_EXEC; + } + GRANARY_ASSERT(false && "Cannot convert permissions into protection flags"); + return PROT_NONE; +} + +#if defined(GRANARY_TARGET_debug) + +static void DebugRanges(const std::vector &pages, + uint32_t pc, uint32_t sp) { + std::cerr << std::endl; + for (const auto &page : pages) { + std::cerr << " 0x" << std::hex << page.base + << "-0x" << page.limit << std::dec + << " perms="; + switch (page.perms) { + case PagePerms::kInvalid: std::cerr << "---"; break; + case PagePerms::kRO: std::cerr << "r--"; break; + case PagePerms::kRW: std::cerr << "rw-"; break; + case PagePerms::kRWX: std::cerr << "rwx"; break; + case PagePerms::kRX: std::cerr << "r-x"; break; + } + std::cerr << " state="; + switch (page.state) { + case PageState::kReserved: std::cerr << "---"; break; + case PageState::kRO: std::cerr << "r--"; break; + case PageState::kRW: std::cerr << "rw-"; break; + case PageState::kRX: std::cerr << "r-x"; break; + } + if (page.base <= pc && pc < page.limit) { + std::cerr << " PC=0x" << std::hex << pc << std::dec; + } + if (page.base <= sp && sp < page.limit) { + std::cerr << " SP=0x" << std::hex << sp << std::dec; + } + if (page.lazy_base != page.base) { + std::cerr << " LB=0x" << std::hex << page.lazy_base << std::dec; + } + std::cerr << std::endl; + } + std::cerr << std::endl; +} + +#endif + +} // namespace + +Process32::Process32(const Snapshot32 *snapshot) + : base(mmap64(nullptr, kProcessSize, PROT_NONE, + MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0)), + pid(snapshot->exe_num), + text_base(kMaxAddress), + fault_can_recover(false), + schedule_delay(-1), + signal(0), + status(ProcessStatus::kSystemCall), + exec_status(ExecStatus::kReady), + fault_addr(0), + fault_base_addr(0), + fault_index_addr(0), + page_hash(0), + page_hash_is_valid(false), + pages() { + pages.reserve(kReserveNumRanges); + + InitRegs(snapshot); + InitSnapshotPages(snapshot); + InitPages(); + + TryMakeExecutable(); + HashPageRange(); + + GRANARY_IF_DEBUG( DebugRanges(pages, regs.eip, regs.esp); ) +} + +// Initialize the page table. +void Process32::InitPages(void) { + pages.push_back({0, kPageSize, 0, PagePerms::kInvalid, + PageState::kReserved, false, 0}); + pages.push_back({kMaxAddress, kMaxAddress, kMaxAddress, + PagePerms::kInvalid, + PageState::kReserved, false, 0}); +} + +// Copy the data and ranges from the snapshot. +void Process32::InitSnapshotPages(const Snapshot32 *snapshot) { + GRANARY_IF_DEBUG(std::cerr << "Memory maps:" << std::endl; ) + + auto file = snapshot->file; + for (const auto &range : file->ranges) { + if (!range.end) break; + + auto perms = range.Perms(); + auto state = BeginState(perms); + GRANARY_ASSERT(range.begin <= range.end && "Invalid snapshot page range."); + if (range.is_x) { + if (range.begin <= PC() && range.end > PC()) { + text_base = range.begin; + if (range.is_w) { + state = PageState::kRX; + } + } + } + + pages.push_back({range.begin, range.end, range.lazy_begin, + perms, state, false, 0}); + + // Copy the actual range into the process; this might be smaller than the + // demand-mapped range. + range.CopyFromFileIntoMem(snapshot->fd, base, state); + } +} + +Process32 *Process32::Revive(const Snapshot32 *snapshot) { + return new Process32(snapshot); +} + +Process32::~Process32(void) { + GRANARY_IF_ASSERT( errno = 0; ) + munmap(base, kProcessSize); + GRANARY_ASSERT(!errno && "Unable to unmap process address space."); +} + +namespace { + +// Hash an a page range by trying to hash each individual page in that range. +// We go one page at a time in order to establish whether or not the page is +// readable (and hence hashable). +static void HashRange(const Process32 *process, const PageRange32 &range) { + XXH32_state_t digest; + uint8_t byte; + XXH32_reset(&digest, range.base); + auto num_pages = (range.limit - range.base) / kPageSize; + auto addr32 = range.base; + for (auto i = 0U; i < num_pages; ++i, addr32 += kPageSize) { + auto addr64 = process->ConvertAddress(addr32); + if (process->TryRead(reinterpret_cast(addr64), byte)) { + XXH32_update(&digest, addr64, kPageSize); + } + } + range.hash_is_valid = true; + range.hash = XXH32_digest(&digest); +} + +// Find a page range that contains an address. +static PageRange32 *FindRange(std::vector &pages, Addr32 addr) { + for (auto &range : pages) { + if (range.base <= addr && addr < range.limit) return ⦥ + } + return nullptr; +} + +// Check the consistency of page ranges. +static void CheckConsistency(const std::vector &pages) { + for (auto page : pages) { + GRANARY_ASSERT(page.base <= page.limit && "Invalid page range."); + GRANARY_ASSERT(page.base == (page.base & kPageMask) && + "Invalid page base address."); + GRANARY_ASSERT(page.limit == (page.limit & kPageMask) && + "Invalid page limit address."); + GRANARY_ASSERT(page.base <= page.lazy_base && "Invalid lazy base (1)."); + GRANARY_ASSERT(page.limit >= page.lazy_base && "Invalid lazy base (2)."); + } +} + +} // namespace + +// Returns true if the page associated with `pc32` is already executable, or +// can be placed into an executable state. +bool Process32::CanExecute(AppPC32 pc32) { + if (auto range = FindRange(pages, pc32)) { + if (PageState::kRX == range->state) { + return true; + } else if (PagePerms::kRWX == range->perms) { + return TryChangeState(pc32, PageState::kRW, PageState::kRX); + } else { + return false; + } + } + return false; +} + +// Returns true if writing to read-only page should invalidate the page +// hash and make the page read-write (in the case that the page is RWX). +bool Process32::TryMakeWritable(Addr32 addr32) { + return TryChangeState(addr32, PageState::kRX, PageState::kRW); +} + +// Invalidates the page hash if the pages associated with a PC can be +// put into an executable state. +bool Process32::TryMakeExecutable(void) { + return TryChangeState(PC(), PageState::kRW, PageState::kRX); +} + +// Tries to lazily map the address if it is marked as having this capability. +bool Process32::TryLazyMap(Addr32 addr32) { + Addr32 page32 = addr32 & kPageMask; + auto range = FindRange(pages, page32); + if (!range || range->lazy_base == range->base) { + return false; + } + + GRANARY_ASSERT(range->lazy_base > range->base); + if ((range->lazy_base - kPageSize) != page32) { + return false; + } + + auto prot = PROT_READ; + if (PageState::kRW == range->state) prot |= PROT_WRITE; + + GRANARY_IF_ASSERT( errno = 0; ) + mprotect( + reinterpret_cast(reinterpret_cast(base) + page32), + kPageSize, + prot); + GRANARY_ASSERT(!errno && "Unable to lazy-map page."); + + range->lazy_base = page32; + return true; +} + +// Tries to change the state of some page ranges from `old_state` to +// `new_state`. +bool Process32::TryChangeState(Addr32 addr32, PageState old_state, + PageState new_state) { + + // Make sure the old state matches up with our expectation. + + const Addr32 base32 = addr32 & kPageMask; + auto range = FindRange(pages, base32); + if (!range || range->state != old_state) { + return false; + } + + // The address is at the beginning of a page range; modify the range in place. + if (base32 == range->base) { + range->state = new_state; + range->hash = 0; + range->hash_is_valid = false; + return true; + } + + // Okay, go split the range if possible. + std::vector new_pages; + new_pages.reserve(std::max(kReserveNumRanges, pages.size() + 1)); + + for (const auto &page : pages) { + if (&page != range) { + new_pages.push_back(page); + } + } + + GRANARY_ASSERT(range->base <= range->lazy_base); + GRANARY_ASSERT(range->base < base32); + GRANARY_ASSERT(base32 < range->limit); + + PageRange32 low = { + range->base, base32, range->base, range->perms, old_state, false, 0}; + + PageRange32 high = { + base32, range->limit, base32, range->perms, new_state, false, 0}; + + if (range->base != range->lazy_base) { + low.lazy_base = std::min(base32, range->lazy_base); + high.lazy_base = std::max(base32, range->lazy_base); + } + + GRANARY_ASSERT(low.base <= low.lazy_base && low.lazy_base <= low.limit); + GRANARY_ASSERT(high.base <= high.lazy_base && high.lazy_base <= high.limit); + + new_pages.push_back(low); + new_pages.push_back(high); + + auto old_range = *range; + range = nullptr; + pages.swap(new_pages); + + CheckConsistency(pages); + + // Invalidate the global page hash. The next code cache lookup will + // trigger new translations. + page_hash_is_valid = false; + page_hash = 0; + + auto prot = PROT_READ; + if (PageState::kRW == new_state) prot |= PROT_WRITE; + + GRANARY_IF_ASSERT( errno = 0; ) + mprotect(ConvertAddress(base32), old_range.limit - base32, prot); + GRANARY_ASSERT(!errno && "Unable to change protections on RWX pages."); + + return true; +} + +// Computes the page hash. +uint32_t Process32::HashPageRange(void) const { + GRANARY_DEBUG( std::cerr << pid << " Process32::HashPageRange" << std::endl; ) + XXH32_state_t digest; + XXH32_reset(&digest, static_cast(pid)); + + auto num_pages = pages.size(); + XXH32_update(&digest, &num_pages, sizeof num_pages); + + for (auto &page : pages) { + if (PageState::kRX == page.state) { + if (!page.hash_is_valid) HashRange(this, page); + XXH32_update(&digest, &(page.hash), sizeof page.hash); + } + } + + page_hash = XXH32_digest(&digest) & 0x00FFFFFFU; // Keep low 24 bits. + page_hash_is_valid = true; + + return page_hash; +} + +// Allocates some memory. +Addr32 Process32::Allocate(size_t num_bytes, PagePerms perms) { + GRANARY_ASSERT(0 < num_bytes); + GRANARY_ASSERT(num_bytes == (num_bytes & kPageMask)); + + std::sort(pages.begin(), pages.end()); + + GRANARY_IF_DEBUG( DebugRanges(pages, regs.eip, regs.esp); ) + + // Out of memory. + auto addr32 = AllocateFromHighMem(num_bytes, perms); + if (!addr32) return 0; + + CheckConsistency(pages); + + GRANARY_IF_DEBUG( DebugRanges(pages, regs.eip, regs.esp); ) + + auto addr64 = ConvertAddress(addr32); + GRANARY_IF_ASSERT( errno = 0; ) + auto ret = mmap64(addr64, num_bytes, PermsToProt(perms), + MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); + GRANARY_ASSERT(!errno && "Unable to map newly allocated process32 memory."); + if (ret != addr64) return 0; + + // Invalidate the page hash because we've potentially allocated new code. + if (PagePerms::kRX == perms || PagePerms::kRWX == perms) { + page_hash_is_valid = false; + page_hash = 0; + } + + return addr32; +} + +// Frees some memory. This builds a new list of page intervals. +// +// Note: This does not alter the sortedness of the page tables. +void Process32::Deallocate(Addr32 addr32, size_t num_bytes) { + GRANARY_ASSERT(0 < num_bytes); + GRANARY_ASSERT(addr32 == (addr32 & kPageMask)); + GRANARY_ASSERT(num_bytes == (num_bytes & kPageMask)); + + auto addr32_limit = addr32 + static_cast(num_bytes); + GRANARY_ASSERT(addr32 < addr32_limit && "Invalid deallocate page range."); + + std::sort(pages.begin(), pages.end()); + + auto invalidate_page_hash = false; + + // Start by splitting up the existing pages; this lets us bail out on the + // process without actually losing info. + std::vector new_pages; + std::vector removed_pages; + new_pages.reserve(std::max(kReserveNumRanges, pages.size())); + removed_pages.reserve(4); + + for (auto page : pages) { + auto deallocated = false; + + // Not allowed to unmap certain pages (e.g. boundary pages). + if (PagePerms::kInvalid == page.perms || + PageState::kReserved == page.state) { + new_pages.push_back(page); + + // No overlap. + } else if (addr32 >= page.limit || addr32_limit <= page.base) { + new_pages.push_back(page); + + // This page is fully contained by the deallocation range. + } else if (addr32 <= page.base && page.limit <= addr32_limit) { + deallocated = true; + removed_pages.push_back(page); + + // Overlap at the beginning. + } else if (addr32 == page.base) { + GRANARY_ASSERT(addr32_limit < page.limit && + "Incorrectly identified prefix range."); + deallocated = true; + + removed_pages.push_back({ + page.base, addr32_limit, page.base, page.perms, page.state, false, 0}); + + PageRange32 high = { + addr32_limit, page.limit, addr32_limit, + page.perms, page.state, false, 0}; + + if (page.base != page.lazy_base) { + high.lazy_base = std::max(addr32_limit, page.lazy_base); + } + + new_pages.push_back(high); + + // Overlap at the end. + } else if (addr32_limit == page.limit) { + GRANARY_ASSERT(addr32 > page.base && + "Incorrectly identified suffix range."); + deallocated = true; + + removed_pages.push_back({ + addr32, page.limit, 0, page.perms, page.state, false, 0}); + + PageRange32 low = { + page.base, addr32, page.base, page.perms, page.state, false, 0}; + + if (page.base != page.lazy_base) { + low.lazy_base = std::min(addr32, page.lazy_base); + } + + new_pages.push_back(low); + + // Deallocation range is fully contained within the current range. + } else { + deallocated = true; + removed_pages.push_back({ + addr32, addr32_limit, 0, page.perms, page.state, false, 0}); + + PageRange32 low = { + page.base, addr32, page.base, page.perms, page.state, false, 0}; + + PageRange32 high = { + addr32_limit, page.limit, addr32_limit, + page.perms, page.state, false, 0}; + + if (page.base != page.lazy_base) { + low.lazy_base = std::min(addr32, page.lazy_base); + high.lazy_base = std::max(addr32_limit, page.lazy_base); + } + + new_pages.push_back(low); + new_pages.push_back(high); + } + + if (deallocated && page.hash_is_valid && + (PagePerms::kRX == page.perms || PagePerms::kRWX == page.perms)) { + invalidate_page_hash = true; + } + } + + // Unmap the various sub page ranges. + GRANARY_IF_ASSERT( errno = 0; ) + for (auto page : removed_pages) { + munmap(ConvertAddress(page.base), page.limit - page.base); + GRANARY_ASSERT(!errno && "Unable to unmap deallocated process32 memory."); + } + + // Swap the page lists. + pages.swap(new_pages); + + CheckConsistency(pages); + + if (invalidate_page_hash && page_hash_is_valid) { + page_hash_is_valid = false; + page_hash = 0; + } +} + +// Allocates `num_pages` of memory with permission `perms` at a "variable" +// address. The address at which the pages are allocated is returned. +// +// Performs a linear scan to perform a first-fit of the pages into memory. +// The scan starts from high memory and works its way down. +// +// Note: `num_bytes` must be a multiple of `kPageSize`. +Addr32 Process32::AllocateFromHighMem(size_t num_bytes, PagePerms perms) { + GRANARY_ASSERT(2 <= pages.size() && "Must have at least two page ranges."); + + const auto end = pages.end(); + for (auto bracket = pages.begin(); bracket != end; ) { + auto high = *bracket++; + if (!high.base) break; // Zero page. + if (high.base > kMaxAddress) continue; // Stack. + if (num_bytes > high.base) break; // No more space. + + const auto low = *bracket; + size_t range_base = low.limit; + size_t range_limit = high.base; + + GRANARY_ASSERT(range_base <= range_limit && "Invalid page range."); + + size_t range_size = range_limit - range_base; + if (num_bytes > range_size) { + continue; + } + + auto alloc_base = high.base - static_cast(num_bytes); + + GRANARY_ASSERT(alloc_base < high.base && "Invalid allocated range."); + pages.push_back({alloc_base, high.base, alloc_base, perms, + BeginState(perms), false, 0}); + return alloc_base; + } + + return 0; +} + +} // namespace os +} // namespace granary diff --git a/granary/os/process.h b/granary/os/process.h new file mode 100644 index 0000000..ece32c1 --- /dev/null +++ b/granary/os/process.h @@ -0,0 +1,317 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_PROCESS_H_ +#define GRANARY_OS_PROCESS_H_ + +#include "granary/os/page.h" + +#include + +#include +#include + +#include +#include + +namespace granary { +namespace os { + +enum class ProcessStatus { + kError, + kIgnorableError, + kDone, + kSystemCall +}; + +enum class ExecStatus { + kInvalid, + kReady, + kBlocked +}; + +namespace detail { + +template struct Value; + +template <> +struct Value<1> { + typedef uint8_t Type; +}; + +template <> +struct Value<2> { + typedef uint16_t Type; +}; + +template <> +struct Value<4> { + typedef uint32_t Type; +}; + +template <> +struct Value<8> { + typedef uint64_t Type; +}; + +} // namespace detail + +class Snapshot32; +class Process32; + +typedef std::vector Process32Group; + +extern GRANARY_THREAD_LOCAL(Process32 *) gProcess; + +// Represents a single-threaded 32-bit process's state. +class Process32 final { + public: + static Process32 *Revive(const Snapshot32 *snapshot); + ~Process32(void); + + // Converts a 32-bit pointer into a 64-bit pointer. + inline Addr64 ConvertAddress(Addr32 addr32) const { + return reinterpret_cast( + reinterpret_cast(base) + addr32); + } + + // Converts a 64-bit code pointer into a 32-bit pointer. + inline Addr32 ConvertAddress(Addr64 addr64) const { + return static_cast(reinterpret_cast(addr64) - + reinterpret_cast(base)); + } + + inline bool IsProcessAddress(uintptr_t addr64) const { + auto base_addr = reinterpret_cast(base); + return base_addr <= addr64 && addr64 < (base_addr + kProcessSize); + } + + // Converts a 32-bit code pointer into a 64-bit code pointer. + inline AppPC64 ConvertPC(AppPC32 pc32) const { + return reinterpret_cast(base) + pc32; + } + + // Returns this process's ID. + inline pid_t Id(void) const { + return pid; + } + + // Returns the next PC to emulate, or the PC of a recent interrupt. + inline AppPC32 PC(void) const { + return regs.eip; + } + + // Returns the PC of the branch instruction. + inline AppPC32 LastBranchPC(void) const { + return last_branch_pc; + } + + // Allocates some memory. + Addr32 Allocate(size_t num_bytes, PagePerms perms); + + // Frees some memory. + void Deallocate(Addr32 addr, size_t num_bytes); + + // Invalidates the page hash if the pages associated with a PC can be + // put into an executable state. + bool TryMakeExecutable(void); + + // Returns the page hash for this process. + inline uint32_t PageHash(void) { + if (GRANARY_LIKELY(0 != page_hash_is_valid)) return page_hash; + return HashPageRange(); + } + + // Returns true if the page associated with `pc32` is already executable, or + // can be placed into an executable state. + bool CanExecute(AppPC32 pc32); + + // Returns true if writing to read-only page should invalidate the page + // hash and make the page read-write (in the case that the page is RWX). + bool TryMakeWritable(Addr32 addr32); + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wold-style-cast" + + // Returns `true` if we're able to write some data to the process. + template ::type=0> + inline bool TryWrite(T *ptr, V val) const { + typedef typename detail::Value::Type U; + return DoTryWrite((U *) ptr, (U) (T) val); + } + + template ::type=0> + inline bool TryWrite(T *ptr, const T &val) const { + auto dst = (uint8_t *) ptr; + auto src = (const uint8_t *) &val; + for (auto i = 0UL; i < sizeof(T); ++i) { + if (!DoTryWrite(dst++, *src++)) return false; + } + return true; + } + + // Returns `true` if we're able to read some data from the process into `val`. + template ::type=0> + inline bool TryRead(const T *ptr, T &val) const { + typedef typename detail::Value::Type U; + return DoTryRead((const U *) ptr, (U *) &val); + } + + template ::type=0> + inline bool TryRead(const T *ptr, T &val) const { + auto dst = (const uint8_t *) ptr; + auto src = (uint8_t *) &val; + for (auto i = 0UL; i < sizeof(T); ++i) { + if (!DoTryRead(dst++, src++)) return false; + } + return true; + } + +#pragma clang diagnostic pop + + void SynchronizeRegState(ucontext_t *context); + + // Returns true if a signal handler can recover from this fault by returning. + bool RecoverFromTryReadWrite(ucontext_t *context) const; + + // Tries to lazily map the address if it is marked as having this capability. + bool TryLazyMap(Addr32 addr); + + // Restore the saved FPU state. + void RestoreFPUState(void) const; + + // Save the current FPU state. + void SaveFPUState(void); + + const Addr64 base; // 0 + + struct GPRs { + uint32_t edi; // 8 + uint32_t esi; // 12 + uint32_t ebp; // 16 + uint32_t ebx; // 20 + uint32_t edx; // 24 + uint32_t ecx; // 28 + uint32_t eax; // 32 + uint32_t esp; // 36 + + AppPC32 eip; // 40 + + uint32_t eflags; // 44 + } regs; + + // Process ID. + const pid_t pid; // 48 + + // EIP of most recently executed multi-way branch. + AppPC32 last_branch_pc; // 52 + + // Base of `.text` section on init. + AppPC32 text_base; // 56 + + private: + // True if we can recover from a page fault. + mutable bool fault_can_recover; // 60 + + public: + + // Amount of schedule ticks to wait. + int schedule_delay; + + // Last signal delivered to the process. + int signal; + + ProcessStatus status; + ExecStatus exec_status; + + // The address that caused us to fault. + Addr32 fault_addr; + Addr32 fault_base_addr; + Addr32 fault_index_addr; + + private: + friend class Snapshot32; + + explicit Process32(const Snapshot32 *snapshot); + Process32(void) = delete; + + void InitPages(void); + void InitSnapshotPages(const Snapshot32 *snapshot); + void InitRegs(const Snapshot32 *snapshot); + + // Computes the page hash. + uint32_t HashPageRange(void) const; + + // Tries to do a write of a specific size. + bool DoTryWrite(uint32_t *ptr, uint32_t val) const; + bool DoTryWrite(uint16_t *ptr, uint16_t val) const; + bool DoTryWrite(uint8_t *ptr, uint8_t val) const; + + // Tries to do a read of a specific size. + bool DoTryRead(const uint32_t *ptr, uint32_t *val) const; + bool DoTryRead(const uint16_t *ptr, uint16_t *val) const; + bool DoTryRead(const uint8_t *ptr, uint8_t *val) const; + + // Allocates `num_pages` of memory with permission `perms` at a "variable" + // address. The address at which the pages are allocated is returned. + // + // Note: `num_bytes` must be a multiple of `kPageSize`. + Addr32 AllocateFromHighMem(size_t num_bytes, PagePerms perms); + + // Tries to change the state of some page ranges from `old_state` to + // `new_state`. + bool TryChangeState(Addr32 addr, PageState old_state, PageState new_state); + + // 24-bit hash of the RWX pages. + mutable uint32_t page_hash; + + // Tells us whether the page hash is valid. + mutable bool page_hash_is_valid; + + // List of all `mmap`d or `allocate`d pages. + std::vector pages; + + // FPU register state. + alignas(16) struct user_fpregs_struct fpregs; + + GRANARY_DISALLOW_COPY_AND_ASSIGN(Process32); +}; + +// Ensures that the correct `Process32` pointer is set up to handle certain +// kinds of faulting conditions. This is important for things like File +// reading/writing where two processes are involved, as well as some cases of +// page hashing. +class PushProcess32 { + public: + explicit inline PushProcess32(const Process32 *curr) + : prev(gProcess) { + gProcess = const_cast(curr); + } + + inline ~PushProcess32(void) { + gProcess = prev; + } + + private: + PushProcess32(void) = delete; + + Process32 *prev; +}; + +static_assert(0 == __builtin_offsetof(Process32, base), + "Invalid structure packing of `os::Process32`."); + +static_assert(8 == __builtin_offsetof(Process32, regs.edi), + "Invalid structure packing of `os::Process32`."); + +static_assert(40 == __builtin_offsetof(Process32, regs.eip), + "Invalid structure packing of `os::Process32`."); + +static_assert(44 == __builtin_offsetof(Process32, regs.eflags), + "Invalid structure packing of `os::Process32`."); + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_PROCESS_H_ diff --git a/granary/os/schedule.cc b/granary/os/schedule.cc new file mode 100644 index 0000000..f7b9af5 --- /dev/null +++ b/granary/os/schedule.cc @@ -0,0 +1,355 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/schedule.h" + +#include "granary/base/base.h" + +#include "granary/arch/fault.h" + +#include "granary/os/file.h" +#include "granary/os/syscall.h" + +#include "granary/code/cache.h" +#include "granary/code/coverage.h" +#include "granary/code/execute.h" + +#include +#include +#include + +namespace granary { +namespace os { +namespace { +enum : size_t { + kMaxNumSyscalls = 10485760 +}; + +extern "C" void granary_bad_block(void); + +// State that can be restored so that we can recover from `SIGINT` and `SIGTERM` +// and gracefully shut down in a way that persists our runtime state. +static sigjmp_buf gSigTermState; +static auto gSigTermStateValid = false; +static auto gIsRunning = true; + +// The signal that terminated `Schedule`, if any. +static auto gSigTermSignal = 0; + +// Create the file table. +static FileTable CreateFiles(size_t num_processes) { + FileTable files; + auto num_fds = 3 + (1 < num_processes ? num_processes * 2 : 0); + files.reserve(num_fds); + files.push_back(nullptr); // stdin. + files.push_back(nullptr); // stdout. + files.push_back(nullptr); // stderr. + if (1 < num_processes) { + for (auto i = 0UL; i < num_processes; ++i) { + auto file = new File; + files.push_back(file); + files.push_back(file); + } + } + return files; +} + +// Delete all open files. +static void DeleteFiles(FileTable files) { + for (auto fd = 3ULL; fd < files.size(); fd += 2) { + delete files[fd]; + } +} + +// Attaches a signal using `sigaction`. +extern "C" void sys_sigreturn(); +typedef void (SignalHandler) (int, siginfo_t *, void *); +static void signal(int signum, SignalHandler *handler) { + struct sigaction sig; + sig.sa_sigaction = handler; + sig.sa_flags = SA_SIGINFO; + sig.sa_restorer = sys_sigreturn; + sigfillset(&(sig.sa_mask)); + sigaction(signum, &sig, nullptr); +} + +// Handle termination (via an external or keyboard event). +static void CatchInterrupt(int sig, siginfo_t *, void *) { + cache::ClearInlineCache(); + + // If we are persisting stuff, then we might need to queue the interrupt + // until such a time where we know that various memory-mapped files are + // in a consistent state. + if (!IsInterruptible()) { + QueueInterrupt(sig); + return; + + // No idea where we are. We're going to try to just return from wherever + // we are and hope for the best! + } else if (!gSigTermStateValid) { + if (!gSigTermSignal && SIGUSR1 != sig) gSigTermSignal = sig; + gIsRunning = false; + return; + + // We're at a point of quiescence, deliver the interrupt. + } else { + gSigTermSignal = sig; + gSigTermStateValid = false; + siglongjmp(gSigTermState, false); + } +} + +// Handle termination (via an external or keyboard event). +[[noreturn]] +static void CatchNonMaskableInterrupt(int sig, siginfo_t *, void *) { + cache::ClearInlineCache(); + GRANARY_ASSERT(gSigTermStateValid && "Invalid re-use of `gSigTermState`."); + if (!gSigTermSignal && SIGUSR1 != sig) gSigTermSignal = sig; + gSigTermStateValid = false; + siglongjmp(gSigTermState, false); +} + +// Catch a segmentation fault and try to handle it. These can happen for a +// few reasons: +// +// 1) We are accessing some data in the user process that is protected. +// This is a recoverable fault. +// 2) We are writing to some data in the user process that is part of some +// RWX page, but the current state is RX, so we need to change states +// to RW. The next change back to RX invalidates the page hash. +// 3) The emulated user process faults. In this case, we want to catch this +// fault and break out of the interpreter loop. +// 4) The emulator itself faults. This is probably a bug. +static void CatchFault(int sig, siginfo_t *si, void *context_) { + cache::ClearInlineCache(); + + auto context = reinterpret_cast(context_); + granary_crash_pc = context->uc_mcontext.gregs[REG_RIP]; + granary_crash_addr = reinterpret_cast(si->si_addr); + + auto process = os::gProcess; + GRANARY_ASSERT(process); + process->signal = sig; + + const auto fault_addr64 = reinterpret_cast(si->si_addr); + const auto fault_rip64 = static_cast( + context->uc_mcontext.gregs[REG_RIP]); + + GRANARY_ASSERT(process->IsProcessAddress(fault_addr64)); + + const auto fault_addr32 = process->ConvertAddress( + reinterpret_cast(fault_addr64)); + + // Try to write to a RWX page in an RX state into the RW state, OR try to + // write to a demand-mapped page. + if (process->TryLazyMap(fault_addr32) || + process->TryMakeWritable(fault_addr32)) { + return; + } + + // Try to recover from a `TryWrite` or a `TryRead`. + // + // Note: This happens *after* the `TryMakeWritable` because that might + // cause us to implicitly recover. For example, if there's RWX data + // in the RX state, and we try to write to it from within a syscall, + // then we don't want to report an EFAULT when we actually need to + // change the page state to RW. + if (process->RecoverFromTryReadWrite(context)) { + return; + } + + // Make sure we faulted within the code cache. + GRANARY_ASSERT(cache::IsCachePC(fault_rip64)); + + // Fault in the emulated code, rather than within a syscall. Pull out the + // components of the address. + Addr32 base, index, scale, disp; + arch::DecomposeFaultAddr( + process, &base, &index, &scale, &disp, fault_addr32); + process->fault_addr = fault_addr32; + process->fault_base_addr = base; + process->fault_index_addr = index; + context->uc_mcontext.gregs[REG_RIP] = reinterpret_cast( + granary_bad_block); +} + +// Catch a crash. +static void CatchCrash(int sig, siginfo_t *, void *context_) { + cache::ClearInlineCache(); + + GRANARY_DEBUG( std::cerr << " CatchCrash " << sig << std::endl; ) + auto process = os::gProcess; + auto context = reinterpret_cast(context_); + + if (!process) { + granary_crash_pc = context->uc_mcontext.gregs[REG_RIP]; + GRANARY_ASSERT(false && "os::gProcess in CatchCrash is nullptr."); + } + + process->signal = sig; + + // Try to recover from a `TryWrite` or a `TryRead`. + if (SIGBUS == sig && process->RecoverFromTryReadWrite(context)) { + return; + } + + const auto fault_rip64 = static_cast( + context->uc_mcontext.gregs[REG_RIP]); + + // Make sure we faulted within the code cache. + GRANARY_ASSERT(cache::IsCachePC(fault_rip64)); + context->uc_mcontext.gregs[REG_RIP] = reinterpret_cast( + granary_bad_block); +} + +static bool gHasSigHandlers = false; + +static struct { int sig; SignalHandler *handler; } gSignalHandlers[] = { + {SIGINT, CatchInterrupt}, + {SIGTERM, CatchInterrupt}, + {SIGALRM, CatchInterrupt}, + {SIGPIPE, CatchInterrupt}, + {SIGUSR1, CatchNonMaskableInterrupt}, + {SIGSEGV, CatchFault}, + {SIGBUS, CatchCrash}, + {SIGFPE, CatchCrash}, + {SIGSTKFLT, CatchCrash}, + {SIGTRAP, CatchCrash}, + {SIGILL, CatchCrash} +}; + +// Set up various signal handlers. +static void SetupSignals(void) { + if (!gHasSigHandlers) { + gHasSigHandlers = true; + for (auto &pair : gSignalHandlers) { + signal(pair.sig, pair.handler); + } + } + sigset_t set; + sigemptyset(&set); + sigprocmask(SIG_SETMASK, &set, nullptr); +} + +// Perform the actual scheduling of processes. +__attribute__((noinline)) +static void Schedule(Process32Group &processes, FileTable &files) { + Interruptible enable_interrupts; + + // If we were interrupted, then interrupts will be disabled and we'll + // return from `DoSchedule`. + if (sigsetjmp(gSigTermState, true)) { + return; + } + gSigTermStateValid = true; + + auto num_syscalls = 0U; + for (auto made_progress = true; made_progress; ) { + made_progress = false; + + for (auto process : processes) { + + // The process terminated or crashed. + if (!process || + ProcessStatus::kError == process->status || + ProcessStatus::kIgnorableError == process->status || + ProcessStatus::kDone == process->status) { + continue; + } + + PushProcess32 set_process(process); + + + cache::ClearInlineCache(); + + // Allows us to repeat system calls that are in-progress. If the + // status is blocked then we'll try to perform a system call. + // + // Note: The initial state of `process_status` is `kSystemCall` even + // though it isn't really a system call. So initially we come in + // and execute, hopefully up to the first syscall. + if (ExecStatus::kReady == process->exec_status) { + continue_execution: + code::Execute(process); + made_progress = true; + } + + // We need to execute a system call. + if (ProcessStatus::kSystemCall == process->status) { + + // Hard limit on the number of syscalls to avoid OOM conditions. + if (num_syscalls++ >= kMaxNumSyscalls) { + made_progress = false; + break; + } + + // Disable interrupts; handling system calls modifies global state. + Uninterruptible disable_interrupts; + + code::MarkCoveredInputLength(); + + switch (SystemCall(process, files)) { + case SystemCallStatus::kTerminated: + GRANARY_DEBUG( std::cerr << process->Id() << " terminated" + << std::endl; ) + process->status = ProcessStatus::kDone; + break; + + case SystemCallStatus::kComplete: + process->exec_status = ExecStatus::kReady; + made_progress = true; + if (1 == processes.size() && gIsRunning) { + goto continue_execution; + } else { + break; + } + + case SystemCallStatus::kInProgress: + process->exec_status = ExecStatus::kBlocked; + break; + + case SystemCallStatus::kSleeping: + process->exec_status = ExecStatus::kBlocked; + made_progress = true; + break; + } + + // Hit some kind of error (e.g. runtime error or decode error) when + // executing the code. + } else if (ProcessStatus::kError == process->status) { + GRANARY_DEBUG( std::cerr << process->Id() << " crashed" << std::endl; ) + + // Unreachable case: this should never happen. + } else { + return; +// GRANARY_ASSERT(false && "Reached ProcessState::kDone directly from " +// "execute."); + } + } + + // Emulates a `SIGPIPE` if we don't make progress and we haven't already + // retried. + if (!made_progress) { + return; + } + } +} + +} // namespace + +// The main process scheduler. This is closely tied with the behavior of reads +// ands writes to `File` objects. +bool Run(Process32Group processes) { + auto files = CreateFiles(processes.size()); + SetupSignals(); + gSigTermStateValid = false; + memset(gSigTermState, 0, sizeof gSigTermState); + Schedule(processes, files); + gSigTermStateValid = false; + gSigTermSignal = 0; + os::gProcess = nullptr; + DeleteFiles(files); + return 0 != gSigTermSignal; +} + +} // namespace os +} // namespace granary diff --git a/granary/os/schedule.h b/granary/os/schedule.h new file mode 100644 index 0000000..01e1a37 --- /dev/null +++ b/granary/os/schedule.h @@ -0,0 +1,16 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_SCHEDULE_H_ +#define GRANARY_OS_SCHEDULE_H_ + +#include "granary/os/process.h" + +namespace granary { +namespace os { + +bool Run(Process32Group processes); + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_SCHEDULE_H_ diff --git a/granary/os/snapshot.cc b/granary/os/snapshot.cc new file mode 100644 index 0000000..7d11364 --- /dev/null +++ b/granary/os/snapshot.cc @@ -0,0 +1,66 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "granary/os/snapshot.h" + +#include +#include +#include +#include + +namespace granary { +namespace os { +namespace detail { + +// Returns the page permissions for this mapped range. +PagePerms MappedRange32::Perms(void) const { + if (is_w && is_x) { + return PagePerms::kRWX; + } else if (is_x) { + return PagePerms::kRX; + } else if (is_w) { + return PagePerms::kRW; + } else { + return PagePerms::kRO; + } +} + +// Copies some snapshotted memory (stored in the file `snapshot_fd` to `mem`). +void MappedRange32::CopyFromFileIntoMem(int snapshot_fd, void *mem, + PageState state) const { + auto mem_base = reinterpret_cast(mem); + mem = reinterpret_cast(mem_base + begin); + + auto prot = 0; + switch (state) { + case PageState::kReserved: prot = PROT_NONE; break; + case PageState::kRO: prot = PROT_READ; break; + case PageState::kRW: prot = PROT_READ | PROT_WRITE; break; + case PageState::kRX: prot = PROT_READ; break; + } + + GRANARY_IF_ASSERT( errno = 0; ) + mmap64(mem, Size(), prot, MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE, + snapshot_fd, fd_offs); + GRANARY_ASSERT(!errno && "Failed to copy snapshotted memory into process."); + + // Deal with lazily allocated pages. + if (begin < lazy_begin) { + mprotect(mem, lazy_begin - begin, PROT_NONE); + } +} + +} // namespace detail + +// Tears down the snapshot. +Snapshot32::~Snapshot32(void) { + munmap(const_cast(file), sizeof *file); + close(fd); +} + +// Revives a previously created snapshot file. +Snapshot32 *Snapshot32::Revive(int exe_num) { + return new Snapshot32(exe_num); +} + +} // namespace os +} // namespace granary diff --git a/granary/os/snapshot.h b/granary/os/snapshot.h new file mode 100644 index 0000000..304f6e6 --- /dev/null +++ b/granary/os/snapshot.h @@ -0,0 +1,99 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_SNAPSHOT_H_ +#define GRANARY_OS_SNAPSHOT_H_ + +#include "granary/os/page.h" + +#include +#include + +#include +#include + +namespace granary { +namespace os { + +class Process32; + +namespace detail { + +// A range of mapped memory. +struct MappedRange32 final { + public: + inline size_t Size(void) const { + return end - begin; + } + + // Returns the page permissions for this mapped range. + PagePerms Perms(void) const; + + // Copies some snapshotted memory to `mem`. + void CopyFromFileIntoMem(int snapshot_fd, void *mem, PageState state) const; + + uint32_t fd_offs; + uint32_t begin; + uint32_t end; + uint32_t lazy_begin; + bool is_r; + bool is_w; + bool is_x; + uint8_t padding; +} __attribute__((packed)); + +// On-disk layout of a snapshot file. +struct alignas(kPageSize) Snapshot32File final { + public: + struct Meta { + struct { + char magic[4]; + int exe_num; + } __attribute__((packed)); + struct user_regs_struct gregs; + struct user_fpregs_struct fpregs; + }; + + Meta meta; + + enum { + kNumPages = 4, + kNumBytes = kNumPages * os::kPageSize, + + kMaxNumMappedRanges = (kNumBytes - sizeof(Meta)) / sizeof(MappedRange32) + }; + + MappedRange32 ranges[kMaxNumMappedRanges]; +}; + +} // namespace detail + +class Snapshot32 final { + public: + ~Snapshot32(void); + + // Revives a previously created snapshot file. + static Snapshot32 *Revive(int exe_num); + + // Creates the snapshot file. + static void Create(const char *exe_name, int exe_num); + + // Creates the snapshot from a process. + static void Create(const Process32 *); + + private: + friend class Process32; + + int fd; + int exe_num; + const detail::Snapshot32File *file; + + explicit Snapshot32(int exe_num_); + Snapshot32(void) = delete; +}; + +typedef std::vector SnapshotGroup; + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_SNAPSHOT_H_ diff --git a/granary/os/syscall.h b/granary/os/syscall.h new file mode 100644 index 0000000..c608259 --- /dev/null +++ b/granary/os/syscall.h @@ -0,0 +1,23 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef GRANARY_OS_SYSCALL_H_ +#define GRANARY_OS_SYSCALL_H_ + +#include "granary/os/file.h" + +namespace granary { +namespace os { + +enum class SystemCallStatus { + kTerminated, + kComplete, + kInProgress, + kSleeping +}; + +SystemCallStatus SystemCall(Process32 *process, FileTable &files); + +} // namespace os +} // namespace granary + +#endif // GRANARY_OS_SYSCALL_H_ diff --git a/play.cc b/play.cc new file mode 100644 index 0000000..9cea865 --- /dev/null +++ b/play.cc @@ -0,0 +1,469 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +#include "granary/arch/base.h" + +#include "granary/code/branch_tracer.h" +#include "granary/code/cache.h" +#include "granary/code/index.h" +#include "granary/code/coverage.h" + +#include "granary/input/record.h" +#include "granary/input/mutate.h" + +#include "granary/os/process.h" +#include "granary/os/snapshot.h" +#include "granary/os/schedule.h" + +#include "third_party/md5/md5.h" + +DEFINE_bool(about, false, "Show the compile date of grr."); + +DEFINE_string(snapshot_dir, "", "Directory where snapshots are stored."); + +DEFINE_string(output_snapshot_dir, "", "Directory where a state snapshot will " + "be placed. The state snapshot is taken " + "just before the first system call that " + "isn't a (de)allocate. Only one set of " + "snapshots are produced. If more are " + "needed then you need to 'walk up' to " + "one using repeated invocations."); + +DEFINE_int32(snapshot_before_input_byte, 0, + "Produce a snapshot file as late as possible but before the " + "Nth input byte is received."); + +DEFINE_bool(persist, true, "Should the code cache be persisted?"); + +DEFINE_string(persist_dir, "", "Directory path to where runtime state should " + "be persisted. This should be unique for a " + "given set of binaries."); + +DEFINE_int32(num_exe, 1, "Number of executables to run."); + +DEFINE_string(input, "", "Path to an input testcase to replay."); + +DEFINE_string(output_dir, "", "Directory where output testcases " + "are stored."); + +DEFINE_string(input_mutator, "", "What input testcase mutator should " + "be used for running the tests?"); + +DEFINE_int32(num_tests, 0, "The maximum number of testcases to run."); + +DEFINE_bool(remutate, false, "Enable remutating of some stuff."); + +DEFINE_bool(path_coverage, false, "Enable path code coverage?"); + +DEFINE_string(coverage_file, "/dev/null", + "File name in which to save the code coverage data. If " + "/dev/null is specified then the coverage file is not " + "mapped, but coverage instrumentation is enabled."); + +DEFINE_string(output_coverage_file, "/dev/null", + "File name in which to save the code coverage data. If " + "/dev/null is specified then the coverage file is not " + "mapped, but coverage instrumentation is enabled."); + +namespace granary { + +std::string gInput = ""; +extern "C" size_t gInputIndex = 0; + +namespace { + +enum { + kGiveUpAfterEmptyMutations = 5 +}; + +static input::IORecording *gRecordToMutate = nullptr; + +// Creates and returns a snapshot group, where each snapshot is the initial +// memory and register state of a bunch of related processes. +static os::SnapshotGroup CreateSnapshotGroup(void) { + os::SnapshotGroup snapshots; + snapshots.reserve(static_cast(FLAGS_num_exe)); + for (auto i = 1; i <= FLAGS_num_exe; ++i) { + snapshots.push_back(os::Snapshot32::Revive(i)); + } + return snapshots; +} + +// Creates and returns a process group from a snapshot group. +static os::Process32Group CreateProcess32Group( + const os::SnapshotGroup &snapshots) { + os::Process32Group processes; + processes.reserve(snapshots.size()); + for (const auto &snapshot : snapshots) { + processes.push_back(os::Process32::Revive(snapshot)); + } + return processes; +} + +static bool IsCrash(const granary::os::Process32Group &processes) { + for (auto process : processes) { + if (granary::os::ProcessStatus::kError == process->status) { + return true; + } + } + return false; +} + +static void PublishNewInput(std::string &&input, + bool is_crash, + bool covered_new_code) { + GRANARY_ASSERT(!FLAGS_output_dir.empty()); + + if (!input.size()) { + return; + } + + std::stringstream final_path; + std::stringstream temp_path; + temp_path << FLAGS_output_dir << "/.tmp"; + final_path << FLAGS_output_dir << "/"; + + // Try to create a temporary output directory for this input. + std::string temp_dir = temp_path.str(); + mkdir(temp_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + + temp_path << "/"; + if (is_crash) { + temp_path << "crash." << getpid(); + final_path << "crash."; + } else { + temp_path << "input." << getpid(); + final_path << "input."; + } + + auto temp_file = temp_path.str(); + auto fd = open( + temp_file.c_str(), O_CREAT | O_TRUNC | O_RDWR | O_LARGEFILE, 0666); + GRANARY_ASSERT(!errno && "Unable to open the temp output file."); + + write(fd, input.c_str(), input.size()); + GRANARY_ASSERT(!errno && "Unable to write the temp output file."); + + close(fd); + + // Name the file in terms of its code coverage, and the input byte index + // after which new code coverage was first detected. + if (!is_crash && covered_new_code) { + final_path << "cov." << code::PathCoverageHash(); + + // Number of paths covered. + final_path << ".size." << code::GetNumCoveredPaths(); + + // Append to the name the index of first input character after which + // new coverage is produced. + if (covered_new_code) { + auto ilen = code::GetCoveredInputLength(); + if (ilen < gInput.size()) { + final_path << ".at." << ilen; + } + } + + // Name the file in terms of its data. + } else { + final_path << "data."; + MD5 hash; + hash.update(input); + hash.finalize(); + final_path << hash.hexdigest(); + } + + + // Atomically make the new file visible. This permits polling of the output + // directory that will see a consistent view of all the files. + auto final_file = final_path.str(); + if (0 != rename(temp_file.c_str(), final_file.c_str())) { + errno = 0; + unlink(temp_file.c_str()); + GRANARY_ASSERT(!errno && "Couldn't remove temporary testcase."); + GRANARY_ASSERT(false && "Couldn't publish testcase to output directory."); + } +} + +// Runs a testcase, and return `true` if we should continue running. +static bool RunTestCase(const granary::os::SnapshotGroup &snapshot_group) { + auto process_group = CreateProcess32Group(snapshot_group); + + // Record the individual syscalls executed. + auto first_execution = !gRecordToMutate; + auto mutating = !FLAGS_input_mutator.empty(); + auto publishing = !FLAGS_output_dir.empty(); + + input::gRecord = new input::IORecording; + gInputIndex = 0; + + code::BeginPathCoverage(); + auto got_term_signal = os::Run(process_group); + code::EndPathCoverage(); + + std::string output; + + const auto is_crash = IsCrash(process_group); + const auto covered_new_code = code::CoveredNewPaths(); + if (publishing) { + + // If we're doing a mutation run, the the first execution is really just + // a way of setting up an initial recording of the input test for later + // mutation, so we don't want to publish it because that would be redundant. + // That is, we expect that what we get as input for mutation has already + // been processed and therefore cannot contribute new information to a + // downstream tool. + if (mutating) { + if (!first_execution && (is_crash || covered_new_code)) { + output = input::gRecord->ToInput(); + } + + // We're not mutating, so this is probably a "speculative" replay of some + // input, where we don't know if the whole input will be processed by + // the program. In this case, we want to produce an output that represents + // a "corrected" version of the supplied input. + // + // This is useful for handling input mutated by a third-party system. That + // system produces an input, but we want to preserve only the consumed parts + // of that information. + } else { + output = input::gRecord->ToInput(); + } + + if (!output.empty()) { + PublishNewInput(std::move(output), is_crash, covered_new_code); + } + } + + // If we found a crash, then reset how me measure code coverage because we + // don't want the crash coverage to prevent future publication of non- + // crashing inputs that cover some of the new but same paths that the + // crashing input covered. + if (is_crash) { + code::ResetPathCoverage(); + } + + // We want to mutate code. + if (mutating) { + if (!gRecordToMutate) { + gRecordToMutate = input::gRecord; + input::gRecord = nullptr; + + // We're running a mutator, and the user has requested that we perform + // input remutation when an input yields something "new" or interesting. + // In this case, this is a kind of hill climbing, where when we find + // new coverage, we set this new input as the one to mutate in the future. + } else if (FLAGS_remutate && covered_new_code && !first_execution) { + delete gRecordToMutate; + gRecordToMutate = input::gRecord; + input::gRecord = nullptr; + } + } + + // No longer need the record if it's still hanging around. + if (input::gRecord) { + delete input::gRecord; + input::gRecord = nullptr; + } + + // The user wants us to stop, so clean up even if we wanted to continue. + if (got_term_signal && gRecordToMutate) { + delete gRecordToMutate; + gRecordToMutate = nullptr; + } + + for (auto process : process_group) { + delete process; + } + + // If we weren't signaled, then we can keep going. + return !got_term_signal; +} + +} // namespace +} // namespace granary + +extern "C" int main(int argc, char **argv, char **) { + using namespace granary; + google::SetUsageMessage(std::string(argv[0]) + " [options]"); + google::ParseCommandLineFlags(&argc, &argv, false); + + if (FLAGS_about) { + std::cerr << __DATE__ ", " __TIME__ << std::endl; + return EXIT_SUCCESS; + } + + if (0 >= FLAGS_num_exe) { + std::cerr << "One or more executables must be available." << std::endl; + return EXIT_FAILURE; + } + + if (FLAGS_snapshot_dir.empty()) { + std::cerr << "Must provide a unique path to a directory where the " + << "snapshots are located persisted." << std::endl; + return EXIT_FAILURE; + } + + if (FLAGS_persist) { + if (FLAGS_persist_dir.empty()) { + std::cerr << "Must provide a unique path to a directory where the " + << "runtime state can be persisted." << std::endl; + return EXIT_FAILURE; + } + mkdir(FLAGS_persist_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + } + + // Make sure we have a place to output testcases, as well as a special + // temporary directory for collecting testcases before we move them into + // the main directory. + if (!FLAGS_output_dir.empty()) { + mkdir(FLAGS_output_dir.c_str(), + S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + + mkdir((FLAGS_output_dir + "/.tmp").c_str(), + S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + } + + if (!FLAGS_input_mutator.empty() && FLAGS_output_dir.empty()) { + std::cerr << "Must specify --output_dir if using --input_mutator." + << std::endl; + return EXIT_FAILURE; + } + + // Make sure we have a place to output snapshots, as well as a special + // temporary directory for collecting snapshots before we move them into + // the main directory. + if (!FLAGS_output_snapshot_dir.empty()) { + mkdir(FLAGS_output_snapshot_dir.c_str(), + S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + + mkdir((FLAGS_output_snapshot_dir + "/.tmp").c_str(), + S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + errno = 0; // Suppress failures to make the directory. + } else { + FLAGS_snapshot_before_input_byte = 0; + } + + // Read in the input file. + if (!FLAGS_input.empty()) { + errno = 0; + auto fd = open(FLAGS_input.c_str(), O_RDONLY | O_CLOEXEC | O_LARGEFILE); + if (errno) { + std::cerr << "Cannot open or parse file: " << FLAGS_input << std::endl; + return EXIT_FAILURE; + } + + struct stat file_info; + fstat(fd, &file_info); + GRANARY_ASSERT(!errno && "Unable to stat the input file."); + + auto size = static_cast(file_info.st_size); + if (size) { + gInput.resize(size); + read(fd, const_cast(gInput.data()), size); // Super sketchy. + GRANARY_ASSERT(!errno && "Unable to read input file data."); + } + } + + // We'll only allow ourselves to be interrupted by specific locations in + // `os::Schedule`. + Uninterruptible disable_interrupts; + + auto snapshot_group = CreateSnapshotGroup(); + + code::InitBranchTracer(); + code::InitPathCoverage(); + arch::Init(); + index::Init(); + cache::Init(); + + // Start by running the individual testcase. This acts as the normal replayer. + // If branch coverage is enabled, then this also establishes the "base case" + // for coverage that will determine if other tests are published. + if (RunTestCase(snapshot_group) && + !FLAGS_input_mutator.empty()) { + + // Now try to mutate the input testcase using the mutator specified in the + // command-line arguments. + input::gRecord = new input::IORecording; + + while (gRecordToMutate) { + auto old_record_to_mutate = gRecordToMutate; + auto mutator = input::Mutator::Create( + gRecordToMutate, FLAGS_input_mutator); + + gInput.clear(); + while (mutator && gRecordToMutate) { + + for (auto empty = 0; + gInput.empty() && empty < kGiveUpAfterEmptyMutations; + ++empty) { + gInput = mutator->RequestMutation(); + } + + // Done mutating. + if (gInput.empty()) { + delete gRecordToMutate; + gRecordToMutate = nullptr; + break; + } + + if (HasPendingInterrupt() || + !RunTestCase(snapshot_group) || + HasPendingInterrupt()) { + + if (gRecordToMutate) { + delete gRecordToMutate; + gRecordToMutate = nullptr; + break; + } + + } else if (old_record_to_mutate != gRecordToMutate) { + delete mutator; + mutator = input::Mutator::Create( + gRecordToMutate, FLAGS_input_mutator); + } + } + delete mutator; + } + } + + MutePendingInterrupt(); + + if (gRecordToMutate) { + delete gRecordToMutate; + gRecordToMutate = nullptr; + } + + if (input::gRecord) { + delete input::gRecord; + input::gRecord = nullptr; + } + + for (auto snapshot : snapshot_group) { + delete snapshot; + } + + arch::Exit(); + index::Exit(); + cache::Exit(); + code::ExitPathCoverage(); + code::ExitBranchTracer(); + + return EXIT_SUCCESS; +} diff --git a/snapshot.cc b/snapshot.cc new file mode 100644 index 0000000..a2d1752 --- /dev/null +++ b/snapshot.cc @@ -0,0 +1,88 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include +#include +#include +#include +#include + +#include + +#include "granary/os/snapshot.h" + +DEFINE_bool(about, false, "Show the compile date of grr."); + +DEFINE_string(snapshot_dir, "", "Directory where snapshots are be stored."); + +DEFINE_string(output_snapshot_dir, "", "Directory where a state snapshot will " + "be placed. The state snapshot is taken " + "just before the first system call that " + "isn't a (de)allocate. Only one set of " + "snapshots are produced. If more are " + "needed then you need to 'walk up' to " + "one using repeated invocations."); + +DEFINE_string(exe_dir, "", "Path to the directory containing executables " + "1 through N, where N is `--num_exe`."); + +DEFINE_string(exe_prefix, "", "Prefix of each executable name."); + +DEFINE_int32(num_exe, 1, "Number of executables to run."); + +namespace granary { +namespace { + +// Name of the executable to snapshot. +static char gExeName[256] = {'\0'}; + +// Fail if `gExeName` is not an executable file. +static void AssertExecutableExists(void) { + struct stat file_info; + if (stat(gExeName, &file_info) || !(file_info.st_mode & S_IXUSR)) { + std::cerr << "File `" << gExeName << "` does not exist or is not " + << "executable" << std::endl; + exit(EXIT_FAILURE); + } +} + +} // namespace +} // namespace granary + +extern "C" int main(int argc, char **argv, char **) { + using namespace granary; + gflags::SetUsageMessage("grr_snapshot [options]"); + gflags::ParseCommandLineFlags(&argc, &argv, false); + + FLAGS_output_snapshot_dir = FLAGS_snapshot_dir; + + if (FLAGS_about) { + std::cerr << __DATE__ ", " __TIME__ << std::endl; + return EXIT_SUCCESS; + } + + if (0 >= FLAGS_num_exe) { + std::cerr << "One or more executables must be available." << std::endl; + return EXIT_FAILURE; + } + + if (FLAGS_snapshot_dir.empty()) { + std::cerr << "Must provide a unique path to a directory where the " + << "snapshots are located persisted." << std::endl; + return EXIT_FAILURE; + } else { + mkdir(FLAGS_snapshot_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); + } + + signal(SIGCHLD, SIG_IGN); + + // Create the various snapshot files. + for (auto i = 1; i <= FLAGS_num_exe; ++i) { + sprintf(gExeName, "%s/%s%04x", FLAGS_exe_dir.c_str(), + FLAGS_exe_prefix.c_str(), i); + AssertExecutableExists(); + os::Snapshot32::Create(gExeName, i); + } + + return 0; +} + diff --git a/third_party/gflags/AUTHORS.txt b/third_party/gflags/AUTHORS.txt new file mode 100644 index 0000000..887918b --- /dev/null +++ b/third_party/gflags/AUTHORS.txt @@ -0,0 +1,2 @@ +google-gflags@googlegroups.com + diff --git a/third_party/gflags/COPYING.txt b/third_party/gflags/COPYING.txt new file mode 100644 index 0000000..d15b0c2 --- /dev/null +++ b/third_party/gflags/COPYING.txt @@ -0,0 +1,28 @@ +Copyright (c) 2006, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/third_party/gflags/include/gflags/gflags.h b/third_party/gflags/include/gflags/gflags.h new file mode 100644 index 0000000..7ead263 --- /dev/null +++ b/third_party/gflags/include/gflags/gflags.h @@ -0,0 +1,573 @@ +// Copyright (c) 2006, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// --- +// Revamped and reorganized by Craig Silverstein +// +// This is the file that should be included by any file which declares +// or defines a command line flag or wants to parse command line flags +// or print a program usage message (which will include information about +// flags). Executive summary, in the form of an example foo.cc file: +// +// #include "foo.h" // foo.h has a line "DECLARE_int32(start);" +// #include "validators.h" // hypothetical file defining ValidateIsFile() +// +// DEFINE_int32(end, 1000, "The last record to read"); +// +// DEFINE_string(filename, "my_file.txt", "The file to read"); +// // Crash if the specified file does not exist. +// static bool dummy = RegisterFlagValidator(&FLAGS_filename, +// &ValidateIsFile); +// +// DECLARE_bool(verbose); // some other file has a DEFINE_bool(verbose, ...) +// +// void MyFunc() { +// if (FLAGS_verbose) printf("Records %d-%d\n", FLAGS_start, FLAGS_end); +// } +// +// Then, at the command-line: +// ./foo --noverbose --start=5 --end=100 +// +// For more details, see +// doc/gflags.html +// +// --- A note about thread-safety: +// +// We describe many functions in this routine as being thread-hostile, +// thread-compatible, or thread-safe. Here are the meanings we use: +// +// thread-safe: it is safe for multiple threads to call this routine +// (or, when referring to a class, methods of this class) +// concurrently. +// thread-hostile: it is not safe for multiple threads to call this +// routine (or methods of this class) concurrently. In gflags, +// most thread-hostile routines are intended to be called early in, +// or even before, main() -- that is, before threads are spawned. +// thread-compatible: it is safe for multiple threads to read from +// this variable (when applied to variables), or to call const +// methods of this class (when applied to classes), as long as no +// other thread is writing to the variable or calling non-const +// methods of this class. + +#ifndef GFLAGS_GFLAGS_H_ +#define GFLAGS_GFLAGS_H_ + +#include +#include + +#include "../../../../third_party/gflags/include/gflags/gflags_declare.h" // IWYU pragma: export + + +// We always want to export variables defined in user code +#ifndef GFLAGS_DLL_DEFINE_FLAG +# ifdef _MSC_VER +# define GFLAGS_DLL_DEFINE_FLAG __declspec(dllexport) +# else +# define GFLAGS_DLL_DEFINE_FLAG +# endif +#endif + + +namespace GFLAGS_NAMESPACE { + + +// -------------------------------------------------------------------- +// To actually define a flag in a file, use DEFINE_bool, +// DEFINE_string, etc. at the bottom of this file. You may also find +// it useful to register a validator with the flag. This ensures that +// when the flag is parsed from the commandline, or is later set via +// SetCommandLineOption, we call the validation function. It is _not_ +// called when you assign the value to the flag directly using the = operator. +// +// The validation function should return true if the flag value is valid, and +// false otherwise. If the function returns false for the new setting of the +// flag, the flag will retain its current value. If it returns false for the +// default value, ParseCommandLineFlags() will die. +// +// This function is safe to call at global construct time (as in the +// example below). +// +// Example use: +// static bool ValidatePort(const char* flagname, int32 value) { +// if (value > 0 && value < 32768) // value is ok +// return true; +// printf("Invalid value for --%s: %d\n", flagname, (int)value); +// return false; +// } +// DEFINE_int32(port, 0, "What port to listen on"); +// static bool dummy = RegisterFlagValidator(&FLAGS_port, &ValidatePort); + +// Returns true if successfully registered, false if not (because the +// first argument doesn't point to a command-line flag, or because a +// validator is already registered for this flag). +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const bool* flag, bool (*validate_fn)(const char*, bool)); +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int32* flag, bool (*validate_fn)(const char*, int32)); +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int64* flag, bool (*validate_fn)(const char*, int64)); +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint64* flag, bool (*validate_fn)(const char*, uint64)); +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const double* flag, bool (*validate_fn)(const char*, double)); +extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const std::string* flag, bool (*validate_fn)(const char*, const std::string&)); + +// Convenience macro for the registration of a flag validator +#define DEFINE_validator(name, validator) \ + static const bool name##_validator_registered = \ + GFLAGS_NAMESPACE::RegisterFlagValidator(&FLAGS_##name, validator) + + +// -------------------------------------------------------------------- +// These methods are the best way to get access to info about the +// list of commandline flags. Note that these routines are pretty slow. +// GetAllFlags: mostly-complete info about the list, sorted by file. +// ShowUsageWithFlags: pretty-prints the list to stdout (what --help does) +// ShowUsageWithFlagsRestrict: limit to filenames with restrict as a substr +// +// In addition to accessing flags, you can also access argv[0] (the program +// name) and argv (the entire commandline), which we sock away a copy of. +// These variables are static, so you should only set them once. +// +// No need to export this data only structure from DLL, avoiding VS warning 4251. +struct CommandLineFlagInfo { + std::string name; // the name of the flag + std::string type; // the type of the flag: int32, etc + std::string description; // the "help text" associated with the flag + std::string current_value; // the current value, as a string + std::string default_value; // the default value, as a string + std::string filename; // 'cleaned' version of filename holding the flag + bool has_validator_fn; // true if RegisterFlagValidator called on this flag + bool is_default; // true if the flag has the default value and + // has not been set explicitly from the cmdline + // or via SetCommandLineOption + const void* flag_ptr; // pointer to the flag's current value (i.e. FLAGS_foo) +}; + +// Using this inside of a validator is a recipe for a deadlock. +// TODO(user) Fix locking when validators are running, to make it safe to +// call validators during ParseAllFlags. +// Also make sure then to uncomment the corresponding unit test in +// gflags_unittest.sh +extern GFLAGS_DLL_DECL void GetAllFlags(std::vector* OUTPUT); +// These two are actually defined in gflags_reporting.cc. +extern GFLAGS_DLL_DECL void ShowUsageWithFlags(const char *argv0); // what --help does +extern GFLAGS_DLL_DECL void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict); + +// Create a descriptive string for a flag. +// Goes to some trouble to make pretty line breaks. +extern GFLAGS_DLL_DECL std::string DescribeOneFlag(const CommandLineFlagInfo& flag); + +// Thread-hostile; meant to be called before any threads are spawned. +extern GFLAGS_DLL_DECL void SetArgv(int argc, const char** argv); + +// The following functions are thread-safe as long as SetArgv() is +// only called before any threads start. +extern GFLAGS_DLL_DECL const std::vector& GetArgvs(); +extern GFLAGS_DLL_DECL const char* GetArgv(); // all of argv as a string +extern GFLAGS_DLL_DECL const char* GetArgv0(); // only argv0 +extern GFLAGS_DLL_DECL uint32 GetArgvSum(); // simple checksum of argv +extern GFLAGS_DLL_DECL const char* ProgramInvocationName(); // argv0, or "UNKNOWN" if not set +extern GFLAGS_DLL_DECL const char* ProgramInvocationShortName(); // basename(argv0) + +// ProgramUsage() is thread-safe as long as SetUsageMessage() is only +// called before any threads start. +extern GFLAGS_DLL_DECL const char* ProgramUsage(); // string set by SetUsageMessage() + +// VersionString() is thread-safe as long as SetVersionString() is only +// called before any threads start. +extern GFLAGS_DLL_DECL const char* VersionString(); // string set by SetVersionString() + + + +// -------------------------------------------------------------------- +// Normally you access commandline flags by just saying "if (FLAGS_foo)" +// or whatever, and set them by calling "FLAGS_foo = bar" (or, more +// commonly, via the DEFINE_foo macro). But if you need a bit more +// control, we have programmatic ways to get/set the flags as well. +// These programmatic ways to access flags are thread-safe, but direct +// access is only thread-compatible. + +// Return true iff the flagname was found. +// OUTPUT is set to the flag's value, or unchanged if we return false. +extern GFLAGS_DLL_DECL bool GetCommandLineOption(const char* name, std::string* OUTPUT); + +// Return true iff the flagname was found. OUTPUT is set to the flag's +// CommandLineFlagInfo or unchanged if we return false. +extern GFLAGS_DLL_DECL bool GetCommandLineFlagInfo(const char* name, CommandLineFlagInfo* OUTPUT); + +// Return the CommandLineFlagInfo of the flagname. exit() if name not found. +// Example usage, to check if a flag's value is currently the default value: +// if (GetCommandLineFlagInfoOrDie("foo").is_default) ... +extern GFLAGS_DLL_DECL CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name); + +enum GFLAGS_DLL_DECL FlagSettingMode { + // update the flag's value (can call this multiple times). + SET_FLAGS_VALUE, + // update the flag's value, but *only if* it has not yet been updated + // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef". + SET_FLAG_IF_DEFAULT, + // set the flag's default value to this. If the flag has not yet updated + // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef") + // change the flag's current value to the new default value as well. + SET_FLAGS_DEFAULT +}; + +// Set a particular flag ("command line option"). Returns a string +// describing the new value that the option has been set to. The +// return value API is not well-specified, so basically just depend on +// it to be empty if the setting failed for some reason -- the name is +// not a valid flag name, or the value is not a valid value -- and +// non-empty else. + +// SetCommandLineOption uses set_mode == SET_FLAGS_VALUE (the common case) +extern GFLAGS_DLL_DECL std::string SetCommandLineOption (const char* name, const char* value); +extern GFLAGS_DLL_DECL std::string SetCommandLineOptionWithMode(const char* name, const char* value, FlagSettingMode set_mode); + + +// -------------------------------------------------------------------- +// Saves the states (value, default value, whether the user has set +// the flag, registered validators, etc) of all flags, and restores +// them when the FlagSaver is destroyed. This is very useful in +// tests, say, when you want to let your tests change the flags, but +// make sure that they get reverted to the original states when your +// test is complete. +// +// Example usage: +// void TestFoo() { +// FlagSaver s1; +// FLAG_foo = false; +// FLAG_bar = "some value"; +// +// // test happens here. You can return at any time +// // without worrying about restoring the FLAG values. +// } +// +// Note: This class is marked with GFLAGS_ATTRIBUTE_UNUSED because all +// the work is done in the constructor and destructor, so in the standard +// usage example above, the compiler would complain that it's an +// unused variable. +// +// This class is thread-safe. However, its destructor writes to +// exactly the set of flags that have changed value during its +// lifetime, so concurrent _direct_ access to those flags +// (i.e. FLAGS_foo instead of {Get,Set}CommandLineOption()) is unsafe. + +class GFLAGS_DLL_DECL FlagSaver { + public: + FlagSaver(); + ~FlagSaver(); + + private: + class FlagSaverImpl* impl_; // we use pimpl here to keep API steady + + FlagSaver(const FlagSaver&); // no copying! + void operator=(const FlagSaver&); +}__attribute((unused)); + +// -------------------------------------------------------------------- +// Some deprecated or hopefully-soon-to-be-deprecated functions. + +// This is often used for logging. TODO(csilvers): figure out a better way +extern GFLAGS_DLL_DECL std::string CommandlineFlagsIntoString(); +// Usually where this is used, a FlagSaver should be used instead. +extern GFLAGS_DLL_DECL +bool ReadFlagsFromString(const std::string& flagfilecontents, + const char* prog_name, + bool errors_are_fatal); // uses SET_FLAGS_VALUE + +// These let you manually implement --flagfile functionality. +// DEPRECATED. +extern GFLAGS_DLL_DECL bool AppendFlagsIntoFile(const std::string& filename, const char* prog_name); +extern GFLAGS_DLL_DECL bool ReadFromFlagsFile(const std::string& filename, const char* prog_name, bool errors_are_fatal); // uses SET_FLAGS_VALUE + + +// -------------------------------------------------------------------- +// Useful routines for initializing flags from the environment. +// In each case, if 'varname' does not exist in the environment +// return defval. If 'varname' does exist but is not valid +// (e.g., not a number for an int32 flag), abort with an error. +// Otherwise, return the value. NOTE: for booleans, for true use +// 't' or 'T' or 'true' or '1', for false 'f' or 'F' or 'false' or '0'. + +extern GFLAGS_DLL_DECL bool BoolFromEnv(const char *varname, bool defval); +extern GFLAGS_DLL_DECL int32 Int32FromEnv(const char *varname, int32 defval); +extern GFLAGS_DLL_DECL int64 Int64FromEnv(const char *varname, int64 defval); +extern GFLAGS_DLL_DECL uint64 Uint64FromEnv(const char *varname, uint64 defval); +extern GFLAGS_DLL_DECL double DoubleFromEnv(const char *varname, double defval); +extern GFLAGS_DLL_DECL const char *StringFromEnv(const char *varname, const char *defval); + + +// -------------------------------------------------------------------- +// The next two functions parse gflags from main(): + +// Set the "usage" message for this program. For example: +// string usage("This program does nothing. Sample usage:\n"); +// usage += argv[0] + " "; +// SetUsageMessage(usage); +// Do not include commandline flags in the usage: we do that for you! +// Thread-hostile; meant to be called before any threads are spawned. +extern GFLAGS_DLL_DECL void SetUsageMessage(const std::string& usage); + +// Sets the version string, which is emitted with --version. +// For instance: SetVersionString("1.3"); +// Thread-hostile; meant to be called before any threads are spawned. +extern GFLAGS_DLL_DECL void SetVersionString(const std::string& version); + + +// Looks for flags in argv and parses them. Rearranges argv to put +// flags first, or removes them entirely if remove_flags is true. +// If a flag is defined more than once in the command line or flag +// file, the last definition is used. Returns the index (into argv) +// of the first non-flag argument. +// See top-of-file for more details on this function. +#ifndef SWIG // In swig, use ParseCommandLineFlagsScript() instead. +extern GFLAGS_DLL_DECL uint32 ParseCommandLineFlags(int *argc, char*** argv, bool remove_flags); +#endif + + +// Calls to ParseCommandLineNonHelpFlags and then to +// HandleCommandLineHelpFlags can be used instead of a call to +// ParseCommandLineFlags during initialization, in order to allow for +// changing default values for some FLAGS (via +// e.g. SetCommandLineOptionWithMode calls) between the time of +// command line parsing and the time of dumping help information for +// the flags as a result of command line parsing. If a flag is +// defined more than once in the command line or flag file, the last +// definition is used. Returns the index (into argv) of the first +// non-flag argument. (If remove_flags is true, will always return 1.) +extern GFLAGS_DLL_DECL uint32 ParseCommandLineNonHelpFlags(int *argc, char*** argv, bool remove_flags); + +// This is actually defined in gflags_reporting.cc. +// This function is misnamed (it also handles --version, etc.), but +// it's too late to change that now. :-( +extern GFLAGS_DLL_DECL void HandleCommandLineHelpFlags(); // in gflags_reporting.cc + +// Allow command line reparsing. Disables the error normally +// generated when an unknown flag is found, since it may be found in a +// later parse. Thread-hostile; meant to be called before any threads +// are spawned. +extern GFLAGS_DLL_DECL void AllowCommandLineReparsing(); + +// Reparse the flags that have not yet been recognized. Only flags +// registered since the last parse will be recognized. Any flag value +// must be provided as part of the argument using "=", not as a +// separate command line argument that follows the flag argument. +// Intended for handling flags from dynamically loaded libraries, +// since their flags are not registered until they are loaded. +extern GFLAGS_DLL_DECL void ReparseCommandLineNonHelpFlags(); + +// Clean up memory allocated by flags. This is only needed to reduce +// the quantity of "potentially leaked" reports emitted by memory +// debugging tools such as valgrind. It is not required for normal +// operation, or for the google perftools heap-checker. It must only +// be called when the process is about to exit, and all threads that +// might access flags are quiescent. Referencing flags after this is +// called will have unexpected consequences. This is not safe to run +// when multiple threads might be running: the function is +// thread-hostile. +extern GFLAGS_DLL_DECL void ShutDownCommandLineFlags(); + + +// -------------------------------------------------------------------- +// Now come the command line flag declaration/definition macros that +// will actually be used. They're kind of hairy. A major reason +// for this is initialization: we want people to be able to access +// variables in global constructors and have that not crash, even if +// their global constructor runs before the global constructor here. +// (Obviously, we can't guarantee the flags will have the correct +// default value in that case, but at least accessing them is safe.) +// The only way to do that is have flags point to a static buffer. +// So we make one, using a union to ensure proper alignment, and +// then use placement-new to actually set up the flag with the +// correct default value. In the same vein, we have to worry about +// flag access in global destructors, so FlagRegisterer has to be +// careful never to destroy the flag-values it constructs. +// +// Note that when we define a flag variable FLAGS_, we also +// preemptively define a junk variable, FLAGS_no. This is to +// cause a link-time error if someone tries to define 2 flags with +// names like "logging" and "nologging". We do this because a bool +// flag FLAG can be set from the command line to true with a "-FLAG" +// argument, and to false with a "-noFLAG" argument, and so this can +// potentially avert confusion. +// +// We also put flags into their own namespace. It is purposefully +// named in an opaque way that people should have trouble typing +// directly. The idea is that DEFINE puts the flag in the weird +// namespace, and DECLARE imports the flag from there into the current +// namespace. The net result is to force people to use DECLARE to get +// access to a flag, rather than saying "extern GFLAGS_DLL_DECL bool FLAGS_whatever;" +// or some such instead. We want this so we can put extra +// functionality (like sanity-checking) in DECLARE if we want, and +// make sure it is picked up everywhere. +// +// We also put the type of the variable in the namespace, so that +// people can't DECLARE_int32 something that they DEFINE_bool'd +// elsewhere. + +class GFLAGS_DLL_DECL FlagRegisterer { + public: + FlagRegisterer(const char* name, const char* type, + const char* help, const char* filename, + void* current_storage, void* defvalue_storage); +}; + +// If your application #defines STRIP_FLAG_HELP to a non-zero value +// before #including this file, we remove the help message from the +// binary file. This can reduce the size of the resulting binary +// somewhat, and may also be useful for security reasons. + +extern GFLAGS_DLL_DECL const char kStrippedFlagHelp[]; + + +} // namespace GFLAGS_NAMESPACE + + +#ifndef SWIG // In swig, ignore the main flag declarations + +#if defined(STRIP_FLAG_HELP) && STRIP_FLAG_HELP > 0 +// Need this construct to avoid the 'defined but not used' warning. +#define MAYBE_STRIPPED_HELP(txt) \ + (false ? (txt) : GFLAGS_NAMESPACE::kStrippedFlagHelp) +#else +#define MAYBE_STRIPPED_HELP(txt) txt +#endif + +// Each command-line flag has two variables associated with it: one +// with the current value, and one with the default value. However, +// we have a third variable, which is where value is assigned; it's a +// constant. This guarantees that FLAG_##value is initialized at +// static initialization time (e.g. before program-start) rather than +// than global construction time (which is after program-start but +// before main), at least when 'value' is a compile-time constant. We +// use a small trick for the "default value" variable, and call it +// FLAGS_no. This serves the second purpose of assuring a +// compile error if someone tries to define a flag named no +// which is illegal (--foo and --nofoo both affect the "foo" flag). +#define DEFINE_VARIABLE(type, shorttype, name, value, help) \ + namespace fL##shorttype { \ + static const type FLAGS_nono##name = value; \ + /* We always want to export defined variables, dll or no */ \ + GFLAGS_DLL_DEFINE_FLAG type FLAGS_##name = FLAGS_nono##name; \ + type FLAGS_no##name = FLAGS_nono##name; \ + static GFLAGS_NAMESPACE::FlagRegisterer o_##name( \ + #name, #type, MAYBE_STRIPPED_HELP(help), __FILE__, \ + &FLAGS_##name, &FLAGS_no##name); \ + } \ + using fL##shorttype::FLAGS_##name + +// For DEFINE_bool, we want to do the extra check that the passed-in +// value is actually a bool, and not a string or something that can be +// coerced to a bool. These declarations (no definition needed!) will +// help us do that, and never evaluate From, which is important. +// We'll use 'sizeof(IsBool(val))' to distinguish. This code requires +// that the compiler have different sizes for bool & double. Since +// this is not guaranteed by the standard, we check it with a +// COMPILE_ASSERT. +namespace fLB { +struct CompileAssert {}; +typedef CompileAssert expected_sizeof_double_neq_sizeof_bool[ + (sizeof(double) != sizeof(bool)) ? 1 : -1]; +template double GFLAGS_DLL_DECL IsBoolFlag(const From& from); +GFLAGS_DLL_DECL bool IsBoolFlag(bool from); +} // namespace fLB + +// Here are the actual DEFINE_*-macros. The respective DECLARE_*-macros +// are in a separate include, gflags_declare.h, for reducing +// the physical transitive size for DECLARE use. +#define DEFINE_bool(name, val, txt) \ + namespace fLB { \ + typedef ::fLB::CompileAssert FLAG_##name##_value_is_not_a_bool[ \ + (sizeof(::fLB::IsBoolFlag(val)) != sizeof(double))? 1: -1]; \ + } \ + DEFINE_VARIABLE(bool, B, name, val, txt) + +#define DEFINE_int32(name, val, txt) \ + DEFINE_VARIABLE(GFLAGS_NAMESPACE::int32, I, \ + name, val, txt) + +#define DEFINE_int64(name, val, txt) \ + DEFINE_VARIABLE(GFLAGS_NAMESPACE::int64, I64, \ + name, val, txt) + +#define DEFINE_uint64(name,val, txt) \ + DEFINE_VARIABLE(GFLAGS_NAMESPACE::uint64, U64, \ + name, val, txt) + +#define DEFINE_double(name, val, txt) \ + DEFINE_VARIABLE(double, D, name, val, txt) + +// Strings are trickier, because they're not a POD, so we can't +// construct them at static-initialization time (instead they get +// constructed at global-constructor time, which is much later). To +// try to avoid crashes in that case, we use a char buffer to store +// the string, which we can static-initialize, and then placement-new +// into it later. It's not perfect, but the best we can do. + +namespace fLS { + +inline clstring* dont_pass0toDEFINE_string(char *stringspot, + const char *value) { + return new(stringspot) clstring(value); +} +inline clstring* dont_pass0toDEFINE_string(char *stringspot, + const clstring &value) { + return new(stringspot) clstring(value); +} +inline clstring* dont_pass0toDEFINE_string(char *stringspot, + int value); +} // namespace fLS + +// We need to define a var named FLAGS_no##name so people don't define +// --string and --nostring. And we need a temporary place to put val +// so we don't have to evaluate it twice. Two great needs that go +// great together! +// The weird 'using' + 'extern' inside the fLS namespace is to work around +// an unknown compiler bug/issue with the gcc 4.2.1 on SUSE 10. See +// http://code.google.com/p/google-gflags/issues/detail?id=20 +#define DEFINE_string(name, val, txt) \ + namespace fLS { \ + using ::fLS::clstring; \ + static union { void* align; char s[sizeof(clstring)]; } s_##name[2]; \ + clstring* const FLAGS_no##name = ::fLS:: \ + dont_pass0toDEFINE_string(s_##name[0].s, \ + val); \ + static GFLAGS_NAMESPACE::FlagRegisterer o_##name( \ + #name, "string", MAYBE_STRIPPED_HELP(txt), __FILE__, \ + s_##name[0].s, new (s_##name[1].s) clstring(*FLAGS_no##name)); \ + extern GFLAGS_DLL_DEFINE_FLAG clstring& FLAGS_##name; \ + using fLS::FLAGS_##name; \ + clstring& FLAGS_##name = *FLAGS_no##name; \ + } \ + using fLS::FLAGS_##name + +#endif // SWIG + + +// Import gflags library symbols into alternative/deprecated namespace(s) +#include "../../../../third_party/gflags/include/gflags/gflags_gflags.h" + + +#endif // GFLAGS_GFLAGS_H_ diff --git a/third_party/gflags/include/gflags/gflags_completions.h b/third_party/gflags/include/gflags/gflags_completions.h new file mode 100644 index 0000000..f951c1e --- /dev/null +++ b/third_party/gflags/include/gflags/gflags_completions.h @@ -0,0 +1,121 @@ +// Copyright (c) 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --- + +// +// Implement helpful bash-style command line flag completions +// +// ** Functional API: +// HandleCommandLineCompletions() should be called early during +// program startup, but after command line flag code has been +// initialized, such as the beginning of HandleCommandLineHelpFlags(). +// It checks the value of the flag --tab_completion_word. If this +// flag is empty, nothing happens here. If it contains a string, +// however, then HandleCommandLineCompletions() will hijack the +// process, attempting to identify the intention behind this +// completion. Regardless of the outcome of this deduction, the +// process will be terminated, similar to --helpshort flag +// handling. +// +// ** Overview of Bash completions: +// Bash can be told to programatically determine completions for the +// current 'cursor word'. It does this by (in this case) invoking a +// command with some additional arguments identifying the command +// being executed, the word being completed, and the previous word +// (if any). Bash then expects a sequence of output lines to be +// printed to stdout. If these lines all contain a common prefix +// longer than the cursor word, bash will replace the cursor word +// with that common prefix, and display nothing. If there isn't such +// a common prefix, bash will display the lines in pages using 'more'. +// +// ** Strategy taken for command line completions: +// If we can deduce either the exact flag intended, or a common flag +// prefix, we'll output exactly that. Otherwise, if information +// must be displayed to the user, we'll take the opportunity to add +// some helpful information beyond just the flag name (specifically, +// we'll include the default flag value and as much of the flag's +// description as can fit on a single terminal line width, as specified +// by the flag --tab_completion_columns). Furthermore, we'll try to +// make bash order the output such that the most useful or relevent +// flags are the most likely to be shown at the top. +// +// ** Additional features: +// To assist in finding that one really useful flag, substring matching +// was implemented. Before pressing a to get completion for the +// current word, you can append one or more '?' to the flag to do +// substring matching. Here's the semantics: +// --foo Show me all flags with names prefixed by 'foo' +// --foo? Show me all flags with 'foo' somewhere in the name +// --foo?? Same as prior case, but also search in module +// definition path for 'foo' +// --foo??? Same as prior case, but also search in flag +// descriptions for 'foo' +// Finally, we'll trim the output to a relatively small number of +// flags to keep bash quiet about the verbosity of output. If one +// really wanted to see all possible matches, appending a '+' to the +// search word will force the exhaustive list of matches to be printed. +// +// ** How to have bash accept completions from a binary: +// Bash requires that it be informed about each command that programmatic +// completion should be enabled for. Example addition to a .bashrc +// file would be (your path to gflags_completions.sh file may differ): + +/* +$ complete -o bashdefault -o default -o nospace -C \ + '/home/build/eng/bash/bash_completions.sh --tab_completion_columns $COLUMNS' \ + time env binary_name another_binary [...] +*/ + +// This would allow the following to work: +// $ /path/to/binary_name --vmodule +// Or: +// $ ./bin/path/another_binary --gfs_u +// (etc) +// +// Sadly, it appears that bash gives no easy way to force this behavior for +// all commands. That's where the "time" in the above example comes in. +// If you haven't specifically added a command to the list of completion +// supported commands, you can still get completions by prefixing the +// entire command with "env". +// $ env /some/brand/new/binary --vmod +// Assuming that "binary" is a newly compiled binary, this should still +// produce the expected completion output. + + +#ifndef GFLAGS_COMPLETIONS_H_ +#define GFLAGS_COMPLETIONS_H_ + +namespace google { + +extern void HandleCommandLineCompletions(void); + +} + +#endif // GFLAGS_COMPLETIONS_H_ diff --git a/third_party/gflags/include/gflags/gflags_declare.h b/third_party/gflags/include/gflags/gflags_declare.h new file mode 100644 index 0000000..935a20e --- /dev/null +++ b/third_party/gflags/include/gflags/gflags_declare.h @@ -0,0 +1,141 @@ +// Copyright (c) 1999, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// --- +// +// Revamped and reorganized by Craig Silverstein +// +// This is the file that should be included by any file which declares +// command line flag. + +#ifndef GFLAGS_DECLARE_H_ +#define GFLAGS_DECLARE_H_ + + +// --------------------------------------------------------------------------- +// Namespace of gflags library symbols. +#define GFLAGS_NAMESPACE google + +// --------------------------------------------------------------------------- +// Windows DLL import/export. + +// We always want to import the symbols of the gflags library +#ifndef GFLAGS_DLL_DECL +# if 0 && defined(_MSC_VER) +# define GFLAGS_DLL_DECL __declspec(dllimport) +# else +# define GFLAGS_DLL_DECL +# endif +#endif + +// We always want to import variables declared in user code +#ifndef GFLAGS_DLL_DECLARE_FLAG +# ifdef _MSC_VER +# define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport) +# else +# define GFLAGS_DLL_DECLARE_FLAG +# endif +#endif + +// --------------------------------------------------------------------------- +// Flag types +#include +#if 1 +# include // the normal place uint32_t is defined +#elif 1 +# include // the normal place u_int32_t is defined +#elif 1 +# include // a third place for uint32_t or u_int32_t +#endif + +namespace GFLAGS_NAMESPACE { + +#if 1 // C99 +typedef int32_t int32; +typedef uint32_t uint32; +typedef int64_t int64; +typedef uint64_t uint64; +#elif 0 // BSD +typedef int32_t int32; +typedef u_int32_t uint32; +typedef int64_t int64; +typedef u_int64_t uint64; +#elif 0 // Windows +typedef __int32 int32; +typedef unsigned __int32 uint32; +typedef __int64 int64; +typedef unsigned __int64 uint64; +#else +# error Do not know how to define a 32-bit integer quantity on your system +#endif + +} // namespace GFLAGS_NAMESPACE + + +namespace fLS { + +// The meaning of "string" might be different between now and when the +// macros below get invoked (e.g., if someone is experimenting with +// other string implementations that get defined after this file is +// included). Save the current meaning now and use it in the macros. +typedef std::string clstring; + +} // namespace fLS + + +#define DECLARE_VARIABLE(type, shorttype, name) \ + /* We always want to import declared variables, dll or no */ \ + namespace fL##shorttype { extern GFLAGS_DLL_DECLARE_FLAG type FLAGS_##name; } \ + using fL##shorttype::FLAGS_##name + +#define DECLARE_bool(name) \ + DECLARE_VARIABLE(bool, B, name) + +#define DECLARE_int32(name) \ + DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int32, I, name) + +#define DECLARE_int64(name) \ + DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int64, I64, name) + +#define DECLARE_uint64(name) \ + DECLARE_VARIABLE(::GFLAGS_NAMESPACE::uint64, U64, name) + +#define DECLARE_double(name) \ + DECLARE_VARIABLE(double, D, name) + +#define DECLARE_string(name) \ + /* We always want to import declared variables, dll or no */ \ + namespace fLS { \ + using ::fLS::clstring; \ + extern GFLAGS_DLL_DECLARE_FLAG ::fLS::clstring& FLAGS_##name; \ + } \ + using fLS::FLAGS_##name + + +#endif // GFLAGS_DECLARE_H_ diff --git a/third_party/gflags/include/gflags/gflags_gflags.h b/third_party/gflags/include/gflags/gflags_gflags.h new file mode 100644 index 0000000..0c17825 --- /dev/null +++ b/third_party/gflags/include/gflags/gflags_gflags.h @@ -0,0 +1,101 @@ +// Copyright (c) 2014, Andreas Schuh +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// ----------------------------------------------------------------------------- +// Imports the gflags library symbols into an alternative/deprecated namespace. + +#ifndef GFLAGS_GFLAGS_H_ +# error The internal header gflags_gflags.h may only be included by gflags.h +#endif + +#ifndef GFLAGS_NS_GFLAGS_H_ +#define GFLAGS_NS_GFLAGS_H_ + + +namespace gflags { + + +using GFLAGS_NAMESPACE::int32; +using GFLAGS_NAMESPACE::uint32; +using GFLAGS_NAMESPACE::int64; +using GFLAGS_NAMESPACE::uint64; + +using GFLAGS_NAMESPACE::RegisterFlagValidator; +using GFLAGS_NAMESPACE::CommandLineFlagInfo; +using GFLAGS_NAMESPACE::GetAllFlags; +using GFLAGS_NAMESPACE::ShowUsageWithFlags; +using GFLAGS_NAMESPACE::ShowUsageWithFlagsRestrict; +using GFLAGS_NAMESPACE::DescribeOneFlag; +using GFLAGS_NAMESPACE::SetArgv; +using GFLAGS_NAMESPACE::GetArgvs; +using GFLAGS_NAMESPACE::GetArgv; +using GFLAGS_NAMESPACE::GetArgv0; +using GFLAGS_NAMESPACE::GetArgvSum; +using GFLAGS_NAMESPACE::ProgramInvocationName; +using GFLAGS_NAMESPACE::ProgramInvocationShortName; +using GFLAGS_NAMESPACE::ProgramUsage; +using GFLAGS_NAMESPACE::VersionString; +using GFLAGS_NAMESPACE::GetCommandLineOption; +using GFLAGS_NAMESPACE::GetCommandLineFlagInfo; +using GFLAGS_NAMESPACE::GetCommandLineFlagInfoOrDie; +using GFLAGS_NAMESPACE::FlagSettingMode; +using GFLAGS_NAMESPACE::SET_FLAGS_VALUE; +using GFLAGS_NAMESPACE::SET_FLAG_IF_DEFAULT; +using GFLAGS_NAMESPACE::SET_FLAGS_DEFAULT; +using GFLAGS_NAMESPACE::SetCommandLineOption; +using GFLAGS_NAMESPACE::SetCommandLineOptionWithMode; +using GFLAGS_NAMESPACE::FlagSaver; +using GFLAGS_NAMESPACE::CommandlineFlagsIntoString; +using GFLAGS_NAMESPACE::ReadFlagsFromString; +using GFLAGS_NAMESPACE::AppendFlagsIntoFile; +using GFLAGS_NAMESPACE::ReadFromFlagsFile; +using GFLAGS_NAMESPACE::BoolFromEnv; +using GFLAGS_NAMESPACE::Int32FromEnv; +using GFLAGS_NAMESPACE::Int64FromEnv; +using GFLAGS_NAMESPACE::Uint64FromEnv; +using GFLAGS_NAMESPACE::DoubleFromEnv; +using GFLAGS_NAMESPACE::StringFromEnv; +using GFLAGS_NAMESPACE::SetUsageMessage; +using GFLAGS_NAMESPACE::SetVersionString; +using GFLAGS_NAMESPACE::ParseCommandLineNonHelpFlags; +using GFLAGS_NAMESPACE::HandleCommandLineHelpFlags; +using GFLAGS_NAMESPACE::AllowCommandLineReparsing; +using GFLAGS_NAMESPACE::ReparseCommandLineNonHelpFlags; +using GFLAGS_NAMESPACE::ShutDownCommandLineFlags; +using GFLAGS_NAMESPACE::FlagRegisterer; + +#ifndef SWIG +using GFLAGS_NAMESPACE::ParseCommandLineFlags; +#endif + + +} // namespace gflags + + +#endif // GFLAGS_NS_GFLAGS_H_ diff --git a/third_party/gflags/lib/libgflags_nothreads.a b/third_party/gflags/lib/libgflags_nothreads.a new file mode 100644 index 0000000..3395ae0 Binary files /dev/null and b/third_party/gflags/lib/libgflags_nothreads.a differ diff --git a/third_party/md5/md5.cc b/third_party/md5/md5.cc new file mode 100644 index 0000000..31d0879 --- /dev/null +++ b/third_party/md5/md5.cc @@ -0,0 +1,365 @@ +/* MD5 + converted to C++ class by Frank Thilo (thilo@unix-ag.org) + for bzflag (http://www.bzflag.org) + + based on: + + md5.h and md5.c + reference implemantion of RFC 1321 + + Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + +*/ + +/* interface header */ +#include "../../third_party/md5/md5.h" + +#include + + +// Constants for MD5Transform routine. +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wold-style-cast" + +/////////////////////////////////////////////// + +// F, G, H and I are basic MD5 functions. +inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) { + return (x & y) | (~x & z); +} + +inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) { + return (x & z) | (y & ~z); +} + +inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) { + return x^y^z; +} + +inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) { + return y ^ (x | ~z); +} + +// rotate_left rotates x left n bits. +inline MD5::uint4 MD5::rotate_left(uint4 x, unsigned n) { + return (x << n) | (x >> (32-n)); +} + +// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. +// Rotation is separate from addition to prevent recomputation. +inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { + a = rotate_left(a+ F(b,c,d) + x + ac, s) + b; +} + +inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { + a = rotate_left(a + G(b,c,d) + x + ac, s) + b; +} + +inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { + a = rotate_left(a + H(b,c,d) + x + ac, s) + b; +} + +inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { + a = rotate_left(a + I(b,c,d) + x + ac, s) + b; +} + +////////////////////////////////////////////// + +// default ctor, just initailize +MD5::MD5() +{ + init(); +} + +////////////////////////////////////////////// + +// nifty shortcut ctor, compute MD5 for string and finalize it right away +MD5::MD5(const std::string &text) +{ + init(); + update(text.c_str(), text.length()); + finalize(); +} + +////////////////////////////// + +void MD5::init() +{ + finalized=false; + + count[0] = 0; + count[1] = 0; + + // load magic initialization constants. + state[0] = 0x67452301; + state[1] = 0xefcdab89; + state[2] = 0x98badcfe; + state[3] = 0x10325476; +} + +////////////////////////////// + +// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4. +void MD5::decode(uint4 output[], const uint1 input[], size_t len) +{ + for (auto i = 0U, j = 0U; j < len; i++, j += 4) + output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) | + (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24); +} + +////////////////////////////// + +// encodes input (uint4) into output (unsigned char). Assumes len is +// a multiple of 4. +void MD5::encode(uint1 output[], const uint4 input[], size_t len) +{ + for (auto i = 0U, j = 0U; j < len; i++, j += 4) { + output[j] = input[i] & 0xff; + output[j+1] = (input[i] >> 8) & 0xff; + output[j+2] = (input[i] >> 16) & 0xff; + output[j+3] = (input[i] >> 24) & 0xff; + } +} + +////////////////////////////// + +// apply MD5 algo on a block +void MD5::transform(const uint1 block[blocksize]) +{ + uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + decode (x, block, blocksize); + + /* Round 1 */ + FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ + FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ + FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ + FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ + FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ + FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ + FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ + FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ + FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ + FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ + FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ + GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ + GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ + GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ + GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ + GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ + GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ + GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ + GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ + GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ + GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ + HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ + HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ + HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ + HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ + HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ + HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ + HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ + HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ + HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ + II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ + II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ + II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ + II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ + II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ + II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ + II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ + II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ + II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + // Zeroize sensitive information. + memset(x, 0, sizeof x); +} + +////////////////////////////// + +// MD5 block update operation. Continues an MD5 message-digest +// operation, processing another message block +void MD5::update(const unsigned char input[], size_t length) +{ + // compute number of bytes mod 64 + size_t index = (count[0] / 8) % blocksize; + + // Update number of bits + if ((count[0] += (length << 3)) < (length << 3)) + count[1]++; + count[1] += (length >> 29); + + // number of bytes we need to fill in buffer + size_t firstpart = 64 - index; + size_t i = 0; + + // transform as many times as possible. + if (length >= firstpart) + { + // fill buffer first, transform + memcpy(&buffer[index], input, firstpart); + transform(buffer); + + // transform chunks of blocksize (64 bytes) + for (i = firstpart; i + blocksize <= length; i += blocksize) + transform(&input[i]); + + index = 0; + } + else + i = 0; + + // buffer remaining input + memcpy(&buffer[index], &input[i], length-i); +} + +////////////////////////////// + +// for convenience provide a verson with signed char +void MD5::update(const char input[], size_t length) +{ + update((const unsigned char*)input, length); +} + +////////////////////////////// + +// MD5 finalization. Ends an MD5 message-digest operation, writing the +// the message digest and zeroizing the context. +MD5& MD5::finalize() +{ + static unsigned char padding[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + + if (!finalized) { + // Save number of bits + unsigned char bits[8]; + encode(bits, count, 8); + + // pad out to 56 mod 64. + size_t index = (count[0] / 8) % 64; + size_t padLen = (index < 56) ? (56 - index) : (120 - index); + update(padding, padLen); + + // Append length (before padding) + update(bits, 8); + + // Store state in digest + encode(digest, state, 16); + + // Zeroize sensitive information. + memset(buffer, 0, sizeof buffer); + memset(count, 0, sizeof count); + + finalized=true; + } + + return *this; +} + +////////////////////////////// + +// return hex representation of digest as string +std::string MD5::hexdigest() const +{ + if (!finalized) + return ""; + + char buf[33]; + for (int i=0; i<16; i++) + sprintf(buf+i*2, "%02x", digest[i]); + buf[32]=0; + + return std::string(buf); +} + +////////////////////////////// + +std::ostream& operator<<(std::ostream& out, MD5 md5) +{ + return out << md5.hexdigest(); +} + +////////////////////////////// + +std::string md5(const std::string str) +{ + MD5 md5 = MD5(str); + + return md5.hexdigest(); +} + +#pragma clang diagnostic pop diff --git a/third_party/md5/md5.h b/third_party/md5/md5.h new file mode 100644 index 0000000..e347530 --- /dev/null +++ b/third_party/md5/md5.h @@ -0,0 +1,96 @@ +/* MD5 + converted to C++ class by Frank Thilo (thilo@unix-ag.org) + for bzflag (http://www.bzflag.org) + + based on: + + md5.h and md5.c + reference implementation of RFC 1321 + + Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + +*/ + +#ifndef BZF_MD5_H +#define BZF_MD5_H + +#include +#include + + +// a small class for calculating MD5 hashes of strings or byte arrays +// it is not meant to be fast or secure +// +// usage: 1) feed it blocks of uchars with update() +// 2) finalize() +// 3) get hexdigest() string +// or +// MD5(std::string).hexdigest() +// +// assumes that char is 8 bit and int is 32 bit +class MD5 +{ +public: + MD5(); + MD5(const std::string& text); + void update(const unsigned char *buf, size_t length); + void update(const char *buf, size_t length); + + inline void update(const std::string& text) { + return update(text.data(), text.length()); + } + + MD5& finalize(); + std::string hexdigest() const; + friend std::ostream& operator<<(std::ostream&, MD5 md5); + +private: + void init(); + typedef unsigned char uint1; // 8bit + typedef unsigned int uint4; // 32bit + enum {blocksize = 64}; // VC6 won't eat a const static int here + + void transform(const uint1 block[blocksize]); + static void decode(uint4 output[], const uint1 input[], size_t len); + static void encode(uint1 output[], const uint4 input[], size_t len); + + bool finalized; + uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk + uint4 count[2]; // 64bit counter for number of bits (lo, hi) + uint4 state[4]; // digest so far + uint1 digest[16]; // the result + + // low level logic operations + static inline uint4 F(uint4 x, uint4 y, uint4 z); + static inline uint4 G(uint4 x, uint4 y, uint4 z); + static inline uint4 H(uint4 x, uint4 y, uint4 z); + static inline uint4 I(uint4 x, uint4 y, uint4 z); + static inline uint4 rotate_left(uint4 x, unsigned n); + static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); +}; + +std::string md5(const std::string str); + +#endif diff --git a/third_party/radamsa/LICENSE b/third_party/radamsa/LICENSE new file mode 100644 index 0000000..47c06fc --- /dev/null +++ b/third_party/radamsa/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2013 Aki Helin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/third_party/radamsa/radamsa.c b/third_party/radamsa/radamsa.c new file mode 100644 index 0000000..9b0bd57 --- /dev/null +++ b/third_party/radamsa/radamsa.c @@ -0,0 +1,5592 @@ + +#define read radamsa_read +#define write radamsa_write +#define malloc radamsa_malloc +#define realloc radamsa_realloc +#define free radamsa_free +#define main radamsa_main + +#define IGNORE_FD 9999 + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-variable" + +__thread unsigned char heap[] = {2,3,9,114,101,99,117,114,115,105,118,101,2,3,1,43,2, +3,1,45,2,3,4,105,111,116,97,2,3,7,112,97,116,116,101,114,110,2,3,1,61,2,3,1, +42,2,3,1,47,2,3,2,60,60,2,3,2,62,62,2,3,4,116,121,112,101,2,3,3,97,100,100,1, +4,1,12,1,4,1,10,1,4,1,10,1,4,1,14,1,4,1,14,1,4,1,11,1,4,1,11,1,4,1,14,1,4,1, +11,1,4,1,13,1,4,1,12,1,4,1,12,2,3,5,101,114,114,111,114,1,4,1,1,2,3,4,98,97, +110,100,1,4,1,1,2,3,3,98,111,114,1,4,1,1,2,3,4,98,120,111,114,1,4,1,1,2,3,6, +110,101,103,97,116,101,1,4,1,1,2,3,4,100,111,110,101,1,4,1,1,2,3,4,108,105,115, +116,1,4,1,1,2,3,4,114,111,111,116,1,4,1,1,2,3,8,102,105,110,105,115,104,101, +100,1,4,1,1,2,3,7,99,114,97,115,104,101,100,1,4,1,1,2,3,8,101,120,112,101,99, +116,101,100,1,4,1,1,2,3,9,100,101,108,105,118,101,114,101,100,1,4,1,1,2,3,3, +109,111,100,1,4,1,1,2,3,4,101,120,112,116,1,4,1,1,2,3,3,114,101,109,1,4,1,1, +2,3,7,113,117,111,116,114,101,109,1,4,1,1,2,3,4,104,101,108,112,1,4,1,1,2,3, +3,100,105,118,1,4,1,1,2,3,3,105,110,99,1,4,1,1,2,3,7,99,111,109,109,101,110, +116,1,4,1,1,2,3,4,116,97,105,108,1,4,1,1,2,3,4,105,110,116,60,1,4,1,1,2,3,5, +97,98,111,117,116,1,4,1,1,2,3,7,118,101,114,115,105,111,110,1,4,1,1,2,3,4,99, +111,111,107,1,4,1,1,2,3,9,109,97,110,100,97,116,111,114,121,1,4,1,1,2,3,6,112, +108,117,114,97,108,1,4,1,1,2,3,7,100,101,102,97,117,108,116,1,4,1,1,2,3,3,97, +98,115,1,4,1,1,2,3,6,108,101,110,103,116,104,1,4,1,1,2,3,3,109,117,108,1,4,1, +1,2,3,12,109,101,109,111,114,121,45,108,105,109,105,116,1,4,1,1,2,3,7,107,105, +108,108,105,110,103,1,4,1,1,2,3,9,107,105,108,108,101,100,45,98,121,1,4,1,1, +2,3,12,113,114,45,98,105,103,45,115,109,97,108,108,1,4,1,1,2,3,9,110,101,103, +97,116,105,118,101,63,1,4,1,1,2,3,7,114,101,115,117,109,101,100,1,4,1,1,2,3, +8,114,101,108,101,97,115,101,100,1,4,1,1,2,3,4,108,105,110,107,2,3,7,109,97, +105,108,98,111,120,1,4,1,2,1,4,1,2,2,3,6,115,116,100,111,117,116,1,4,1,1,2,3, +5,115,116,100,105,110,1,4,1,1,2,3,4,112,111,114,116,1,4,1,1,2,3,5,97,119,97, +107,101,1,4,1,1,2,3,12,114,105,115,101,45,110,45,115,104,105,110,101,1,4,1,1, +2,3,1,110,1,4,1,1,2,3,6,111,117,116,112,117,116,1,4,1,1,2,3,8,116,101,114,109, +105,110,97,108,1,4,1,1,2,3,2,105,100,2,3,4,112,114,101,100,1,4,1,2,1,4,1,2,2, +3,5,115,104,111,114,116,2,3,4,108,111,110,103,1,4,1,2,1,4,1,2,2,3,3,98,117,103, +1,4,1,1,2,3,2,116,99,2,3,17,97,108,114,101,97,100,121,45,112,114,111,102,105, +108,105,110,103,2,3,4,112,114,111,102,2,3,17,115,116,97,114,116,101,100,45,112, +114,111,102,105,108,105,110,103,2,3,22,110,111,116,45,112,114,111,102,105,108, +105,110,103,45,121,111,117,45,102,111,111,108,1,4,1,5,1,4,1,5,1,4,1,5,1,4,1, +5,1,4,1,5,2,3,14,110,111,116,45,97,45,102,117,110,99,116,105,111,110,1,4,1,1, +2,3,6,114,97,110,100,111,109,1,4,1,1,2,3,10,116,99,112,45,99,108,105,101,110, +116,1,4,1,1,2,3,2,111,102,1,4,1,1,2,3,4,112,108,117,115,1,4,1,1,2,16,28,25,1, +0,23,1,1,2,4,1,1,3,5,1,1,4,6,9,4,8,5,5,4,6,5,2,8,3,17,2,16,3,0,7,184,2,16,3, +0,7,183,2,16,3,0,7,182,2,16,3,0,7,181,2,16,3,0,7,180,2,16,3,0,7,179,2,16,3,0, +7,178,2,16,3,0,7,177,2,16,3,0,7,176,2,16,3,0,7,175,2,16,3,0,7,174,2,16,3,0,7, +173,2,16,3,0,7,172,2,16,3,0,7,171,2,16,3,0,7,170,2,16,3,0,7,169,2,16,3,0,7,168, +2,16,3,0,7,167,2,16,3,0,7,166,2,16,3,0,7,165,2,16,3,0,7,164,2,16,46,25,2,0,10, +1,1,2,5,9,4,3,2,5,1,25,3,0,12,1,1,2,6,5,4,3,5,4,2,6,2,89,1,0,11,1,2,2,5,1,1, +2,3,2,5,2,17,2,16,3,0,7,163,2,16,3,0,7,162,2,16,3,0,7,161,2,16,25,25,2,0,20, +1,1,4,5,1,1,3,6,1,1,2,7,27,4,5,6,7,8,24,8,17,2,16,3,0,7,160,2,16,3,0,7,159,2, +16,34,25,3,0,29,1,1,3,6,77,7,51,6,7,8,51,4,8,9,1,1,2,10,14,4,4,5,5,6,9,5,2,10, +4,17,2,16,3,0,7,158,2,16,3,0,7,157,2,16,25,25,1,0,20,1,1,2,4,14,7,5,141,6,9, +4,9,5,5,4,6,5,2,9,4,17,2,16,3,0,7,156,2,16,3,0,7,155,2,16,3,0,7,154,2,16,29, +25,1,0,24,1,1,2,4,14,13,5,205,6,141,7,5,4,9,5,4,5,6,5,7,6,2,9,4,17,2,16,3,0, +7,153,2,16,3,0,7,152,2,16,3,0,7,151,2,16,3,0,7,150,2,16,3,0,7,149,2,16,3,0,7, +148,2,16,3,0,7,147,2,16,3,0,7,146,2,16,3,0,7,145,2,16,3,0,7,144,2,16,3,0,7,143, +2,16,3,0,7,142,2,16,3,0,7,141,2,16,3,0,7,140,2,16,3,0,7,139,2,16,3,0,7,138,2, +16,3,0,7,137,2,16,3,0,7,136,2,16,3,0,7,135,2,16,3,0,7,134,2,16,3,0,7,133,2,16, +3,0,7,132,2,16,3,0,7,131,2,16,37,25,1,0,32,1,1,2,4,53,4,5,1,1,5,6,1,1,4,7,1, +1,3,8,5,3,4,7,3,5,6,7,8,6,2,7,5,17,2,16,28,25,5,0,23,80,5,17,0,52,5,8,7,6,2, +5,6,3,7,3,9,8,5,2,6,3,24,4,17,2,16,3,0,7,130,2,16,3,0,7,129,2,16,3,0,7,128,2, +16,3,0,7,127,2,16,3,0,7,126,2,16,3,0,7,125,2,16,3,0,7,124,2,16,3,0,7,123,2,16, +3,0,7,122,2,16,3,0,7,121,2,16,3,0,7,120,2,16,3,0,7,119,2,16,3,0,7,118,2,16,3, +0,7,117,2,16,3,0,7,116,2,16,3,0,7,115,2,16,3,0,7,114,2,16,3,0,7,113,2,16,3,0, +7,112,2,16,3,0,7,111,2,16,3,0,7,110,2,16,49,25,3,0,7,1,1,2,6,2,6,4,89,3,0,19, +1,1,3,7,6,5,4,5,4,3,3,5,6,4,7,5,2,5,3,25,2,0,2,24,4,25,1,0,4,77,4,24,4,17,2, +16,3,0,7,109,2,16,3,0,7,108,2,16,3,0,7,107,2,16,3,0,7,106,2,16,3,0,7,105,2,16, +3,0,7,104,2,16,3,0,7,103,2,16,3,0,7,102,2,16,3,0,7,101,2,16,3,0,7,100,2,16,3, +0,7,99,2,16,3,0,7,98,2,16,3,0,7,97,2,16,3,0,7,96,2,16,3,0,7,95,2,16,3,0,7,94, +2,16,3,0,7,93,2,16,3,0,7,92,2,16,3,0,7,91,2,16,3,0,7,90,2,16,3,0,7,89,2,16,3, +0,7,88,2,16,3,0,7,87,2,16,3,0,7,86,2,16,3,0,7,85,2,16,3,0,7,84,2,16,3,0,7,83, +2,16,3,0,7,82,2,16,3,0,7,81,2,16,3,0,7,80,2,16,3,0,7,79,2,16,3,0,7,78,2,16,3, +0,7,77,2,16,3,0,7,76,2,16,3,0,7,75,2,16,3,0,7,74,2,16,3,0,7,73,2,16,3,0,7,72, +2,16,3,0,7,71,2,16,3,0,7,70,2,16,3,0,7,69,2,16,3,0,7,68,2,16,3,0,7,67,2,16,3, +0,7,66,2,16,3,0,7,65,2,16,3,0,7,64,2,16,3,0,7,63,2,16,3,0,7,62,2,16,3,0,7,61, +2,16,3,0,7,60,2,16,3,0,7,59,2,16,3,0,7,58,2,16,3,0,7,57,2,16,3,0,7,56,2,16,3, +0,7,55,2,16,3,0,7,54,2,16,3,0,7,53,2,16,3,0,7,52,2,16,3,0,7,51,2,16,3,0,7,50, +2,16,3,0,7,49,2,16,3,0,7,48,2,16,3,0,7,47,2,16,3,0,7,46,2,16,3,0,7,45,2,16,3, +0,7,44,2,16,3,0,7,43,2,16,3,0,7,42,2,16,3,0,7,41,2,16,3,0,7,40,2,16,3,0,7,39, +2,16,3,0,7,38,2,16,3,0,7,37,2,16,3,0,7,36,2,16,3,0,7,35,2,16,3,0,7,34,2,16,3, +0,7,33,2,16,3,0,7,32,2,16,3,0,7,31,2,16,3,0,7,30,2,16,3,0,7,29,2,16,3,0,7,28, +2,16,3,0,7,27,2,16,3,0,7,26,2,16,3,0,7,25,2,16,3,0,7,24,2,16,3,0,7,23,2,16,3, +0,7,22,2,16,3,0,7,21,2,16,3,0,7,20,2,16,3,0,7,19,2,16,3,0,7,18,2,16,3,0,7,17, +2,16,3,0,7,16,2,16,3,0,7,15,2,16,3,0,7,14,2,16,3,0,7,13,2,16,3,0,7,12,2,16,3, +0,7,11,2,16,3,0,7,10,2,16,3,0,7,9,2,16,3,0,7,8,2,16,3,0,7,7,2,16,3,0,7,6,2,16, +3,0,7,5,2,16,3,0,7,4,2,16,3,0,7,3,2,16,3,0,7,2,2,16,3,0,7,1,2,16,3,0,7,0,2,16, +3,0,6,255,2,16,3,0,6,254,2,16,3,0,6,253,2,16,3,0,6,252,2,16,3,0,6,251,2,16,3, +0,6,250,2,16,3,0,6,249,2,16,3,0,6,248,2,16,3,0,6,247,2,16,3,0,6,246,2,16,3,0, +6,245,2,16,3,0,6,244,2,16,3,0,6,243,2,16,3,0,6,242,2,16,3,0,6,241,2,16,3,0,6, +240,2,16,3,0,6,239,2,16,3,0,6,238,2,16,3,0,6,237,2,16,3,0,6,236,2,16,3,0,6,235, +2,16,3,0,6,234,2,16,3,0,6,233,2,16,3,0,6,232,2,16,3,0,6,231,2,16,3,0,6,230,2, +16,3,0,6,229,2,16,3,0,6,228,2,16,3,0,6,227,2,16,3,0,6,226,2,16,3,0,6,225,2,16, +3,0,6,224,2,16,3,0,6,223,2,16,3,0,6,222,2,16,3,0,6,221,2,16,3,0,6,220,2,16,3, +0,6,219,2,16,3,0,6,218,2,16,3,0,6,217,2,16,3,0,6,216,2,16,3,0,6,215,2,16,3,0, +6,214,2,16,3,0,6,213,2,16,3,0,6,212,2,16,3,0,6,211,2,16,3,0,6,210,2,16,3,0,6, +209,2,16,3,0,6,208,2,16,3,0,6,207,2,16,3,0,6,206,2,16,3,0,6,205,2,16,3,0,6,204, +2,16,3,0,6,203,2,16,3,0,6,202,2,16,3,0,6,201,2,16,3,0,6,200,2,16,3,0,6,199,2, +16,3,0,6,198,2,16,3,0,6,197,2,16,3,0,6,196,2,16,3,0,6,195,2,16,3,0,6,194,2,16, +3,0,6,193,2,16,3,0,6,192,2,16,3,0,6,191,2,16,3,0,6,190,2,16,3,0,6,189,2,16,3, +0,6,188,2,16,3,0,6,187,2,16,3,0,6,186,2,16,3,0,6,185,2,16,3,0,6,184,2,16,3,0, +6,183,2,16,3,0,6,182,2,16,3,0,6,181,2,16,3,0,6,180,2,16,3,0,6,179,2,16,3,0,6, +178,2,16,3,0,6,177,2,16,3,0,6,176,2,16,3,0,6,175,2,16,3,0,6,174,2,16,3,0,6,173, +2,16,3,0,6,172,2,16,3,0,6,171,2,16,3,0,6,170,2,16,3,0,6,169,2,16,3,0,6,168,2, +16,3,0,6,167,2,16,3,0,6,166,2,16,3,0,6,165,2,16,3,0,6,164,2,16,3,0,6,163,2,16, +3,0,6,162,2,16,3,0,6,161,2,16,3,0,6,160,2,16,3,0,6,159,2,16,3,0,6,158,2,16,3, +0,6,157,2,16,3,0,6,156,2,16,3,0,6,155,2,16,3,0,6,154,2,16,3,0,6,153,2,16,3,0, +6,152,2,16,3,0,6,151,2,16,3,0,6,150,2,16,3,0,6,149,2,16,3,0,6,148,2,16,3,0,6, +147,2,16,3,0,6,146,2,16,3,0,6,145,2,16,3,0,6,144,2,16,3,0,6,143,2,16,3,0,6,142, +2,16,3,0,6,141,2,16,3,0,6,140,2,16,3,0,6,139,2,16,3,0,6,138,2,16,3,0,6,137,2, +16,3,0,6,136,2,16,3,0,6,135,2,16,3,0,6,134,2,16,3,0,6,133,2,16,3,0,6,132,2,16, +3,0,6,131,2,16,3,0,6,130,2,16,3,0,6,129,2,16,43,25,3,0,7,1,1,2,6,2,6,3,89,1, +0,27,1,1,3,5,1,1,2,6,14,0,7,9,5,9,5,6,10,4,6,5,7,5,10,4,2,9,4,17,2,16,59,25, +3,0,7,1,1,2,6,2,6,3,25,2,0,18,1,1,2,5,14,0,6,9,5,8,5,4,5,6,4,2,8,3,89,3,0,21, +1,1,3,7,6,5,4,5,4,3,3,1,1,5,4,14,0,5,2,7,4,17,2,16,52,25,3,0,7,1,1,2,6,2,6,3, +89,3,0,21,1,1,3,7,6,5,4,5,4,3,3,1,1,2,4,14,1,5,2,7,4,25,2,0,2,24,4,25,1,0,5, +14,1,4,24,4,17,2,16,54,25,3,0,7,1,1,2,6,2,6,3,25,2,0,18,1,1,2,5,14,1,6,9,5,8, +5,4,5,6,4,2,8,3,89,2,0,16,1,1,3,6,6,4,4,4,3,3,9,5,4,2,6,2,17,2,16,3,0,6,128, +2,16,3,0,6,127,2,16,37,25,3,0,7,1,1,2,6,2,6,3,89,2,0,21,1,2,2,6,1,1,2,7,5,6, +9,5,6,5,4,5,7,4,2,9,4,17,2,16,3,0,6,126,2,16,86,25,3,0,7,1,1,2,6,2,6,3,25,2, +0,2,24,4,89,2,0,21,1,2,2,6,1,1,2,7,5,6,9,5,6,5,4,5,7,4,2,9,4,25,1,0,39,1,1,3, +4,208,4,2,0,24,4,1,2,3,5,4,3,2,4,3,6,1,2,5,4,1,1,2,8,9,5,9,5,6,3,8,5,2,9,3,17, +2,16,3,0,6,125,2,16,3,0,6,124,2,16,3,0,6,123,2,16,3,0,6,122,2,16,3,0,6,121,2, +16,3,0,6,120,2,16,3,0,6,119,2,16,3,0,6,118,2,16,3,0,6,117,2,16,3,0,6,116,2,16, +3,0,6,115,2,16,3,0,6,114,2,16,3,0,6,113,2,16,3,0,6,112,2,16,3,0,6,111,2,16,3, +0,6,110,2,16,3,0,6,109,2,16,3,0,6,108,2,16,3,0,6,107,2,16,3,0,6,106,2,16,3,0, +6,105,2,16,3,0,6,104,2,16,3,0,6,103,2,16,3,0,6,102,2,16,3,0,6,101,2,16,3,0,6, +100,2,16,3,0,6,99,2,16,3,0,6,98,2,16,3,0,6,97,2,16,3,0,6,96,2,16,3,0,6,95,2, +16,3,0,6,94,2,16,3,0,6,93,2,16,54,25,1,0,49,1,2,2,4,1,1,3,5,1,1,4,6,1,1,5,7, +1,1,6,8,1,1,7,9,3,7,2,3,5,6,7,8,9,10,1,1,2,5,9,4,8,5,3,4,10,3,2,8,3,17,2,16, +3,0,6,92,2,16,67,25,1,0,62,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,1,1,5,8,1,1,6,9,1, +1,7,10,1,1,8,11,1,1,9,12,3,10,2,3,5,6,7,8,9,10,11,12,13,5,4,8,3,4,5,6,5,13,3, +2,8,3,17,2,16,3,0,6,91,2,16,3,0,6,90,2,16,3,0,6,89,2,16,3,0,6,88,2,16,3,0,6, +87,2,16,3,0,6,86,2,16,3,0,6,85,2,16,3,0,6,84,2,16,3,0,6,83,2,16,3,0,6,82,2,16, +3,0,6,81,2,16,3,0,6,80,2,16,3,0,6,79,2,16,3,0,6,78,2,16,3,0,6,77,2,16,3,0,6, +76,2,16,3,0,6,75,2,16,3,0,6,74,2,16,3,0,6,73,2,16,3,0,6,72,2,16,3,0,6,71,2,16, +3,0,6,70,2,16,3,0,6,69,2,16,3,0,6,68,2,16,3,0,6,67,2,16,3,0,6,66,2,16,3,0,6, +65,2,16,3,0,6,64,2,16,3,0,6,63,2,16,3,0,6,62,2,16,3,0,6,61,2,16,3,0,6,60,2,16, +3,0,6,59,2,16,3,0,6,58,2,16,3,0,6,57,2,16,3,0,6,56,2,16,3,0,6,55,2,16,3,0,6, +54,2,16,3,0,6,53,2,16,3,0,6,52,2,16,3,0,6,51,2,16,3,0,6,50,2,16,3,0,6,49,2,16, +3,0,6,48,2,16,3,0,6,47,2,16,3,0,6,46,2,16,3,0,6,45,2,16,3,0,6,44,2,16,3,0,6, +43,2,16,3,0,6,42,2,16,3,0,6,41,2,16,3,0,6,40,2,16,3,0,6,39,2,16,3,0,6,38,2,16, +3,0,6,37,2,16,3,0,6,36,2,16,3,0,6,35,2,16,3,0,6,34,2,16,3,0,6,33,2,16,3,0,6, +32,2,16,3,0,6,31,2,16,3,0,6,30,2,16,3,0,6,29,2,16,3,0,6,28,2,16,32,25,1,0,27, +1,1,2,4,51,3,4,5,14,21,6,1,1,3,7,35,6,7,5,3,1,1,4,9,2,9,1,17,2,16,3,0,6,27,2, +16,3,0,6,26,2,16,31,25,1,0,26,1,1,2,4,51,3,4,5,14,21,6,14,5,7,35,6,7,5,3,1,1, +3,9,2,9,1,17,2,16,3,0,6,25,2,16,3,0,6,24,2,16,3,0,6,23,2,16,3,0,6,22,2,16,3, +0,6,21,2,16,3,0,6,20,2,16,3,0,6,19,2,16,3,0,6,18,2,16,3,0,6,17,2,16,24,25,1, +0,19,14,22,4,1,1,2,5,35,4,5,3,3,1,1,3,7,2,7,1,17,2,16,3,0,6,16,2,16,3,0,6,15, +2,16,3,0,6,14,2,16,3,0,6,13,2,16,3,0,6,12,2,16,3,0,6,11,2,16,3,0,6,10,2,16,3, +0,6,9,2,16,3,0,6,8,2,16,3,0,6,7,2,16,3,0,6,6,2,16,3,0,6,5,2,16,3,0,6,4,2,16, +3,0,6,3,2,16,3,0,6,2,2,16,3,0,6,1,2,16,3,0,6,0,2,16,3,0,5,255,2,16,3,0,5,254, +2,16,3,0,5,253,2,16,3,0,5,252,2,16,3,0,5,251,2,16,3,0,5,250,2,16,3,0,5,249,2, +16,3,0,5,248,2,16,3,0,5,247,2,16,3,0,5,246,2,16,3,0,5,245,2,16,3,0,5,244,2,16, +3,0,5,243,2,16,22,25,3,0,17,1,1,2,6,6,5,3,5,4,3,3,9,5,4,2,6,2,17,2,16,3,0,5, +242,2,16,3,0,5,241,2,16,3,0,5,240,2,16,3,0,5,239,2,16,3,0,5,238,2,16,3,0,5,237, +2,16,3,0,5,236,2,16,3,0,5,235,2,16,3,0,5,234,2,16,3,0,5,233,2,16,3,0,5,232,2, +16,24,25,1,0,19,14,11,4,1,1,2,5,35,4,5,3,3,1,1,3,7,2,7,1,17,2,16,3,0,5,231,2, +16,3,0,5,230,2,16,3,0,5,229,2,16,3,0,5,228,2,16,3,0,5,227,2,16,3,0,5,226,2,16, +3,0,5,225,2,16,3,0,5,224,2,16,3,0,5,223,2,16,3,0,5,222,2,16,3,0,5,221,2,16,3, +0,5,220,2,16,3,0,5,219,2,16,3,0,5,218,2,16,3,0,5,217,2,16,3,0,5,216,2,16,53, +25,1,0,48,1,1,3,4,52,4,5,1,1,2,6,51,5,6,7,14,15,8,35,8,3,7,9,53,4,5,1,1,5,6, +1,1,6,12,4,4,2,2,9,12,3,1,1,4,4,2,6,4,17,2,16,3,0,5,215,2,16,3,0,5,214,2,16, +3,0,5,213,2,16,3,0,5,212,2,16,40,25,1,0,35,1,1,3,4,1,1,2,5,51,4,5,6,1,1,4,7, +51,7,6,8,14,15,9,35,9,3,8,3,1,1,5,11,2,11,1,17,2,16,3,0,5,211,2,16,3,0,5,210, +2,16,3,0,5,209,2,16,3,0,5,208,2,16,3,0,5,207,2,16,3,0,5,206,2,16,3,0,5,205,2, +16,3,0,5,204,2,16,3,0,5,203,2,16,3,0,5,202,2,16,3,0,5,201,2,16,3,0,5,200,2,16, +3,0,5,199,2,16,3,0,5,198,2,16,3,0,5,197,2,16,3,0,5,196,2,16,3,0,5,195,2,16,3, +0,5,194,2,16,3,0,5,193,2,16,3,0,5,192,2,16,3,0,5,191,2,16,3,0,5,190,2,16,3,0, +5,189,2,16,3,0,5,188,2,16,3,0,5,187,2,16,3,0,5,186,2,16,3,0,5,185,2,16,3,0,5, +184,2,16,3,0,5,183,2,16,3,0,5,182,2,16,3,0,5,181,2,16,3,0,5,180,2,16,3,0,5,179, +2,16,3,0,5,178,2,16,3,0,5,177,2,16,3,0,5,176,2,16,3,0,5,175,2,16,3,0,5,174,2, +16,3,0,5,173,2,16,3,0,5,172,2,16,3,0,5,171,2,16,3,0,5,170,2,16,3,0,5,169,2,16, +3,0,5,168,2,16,3,0,5,167,2,16,3,0,5,166,2,16,3,0,5,165,2,16,3,0,5,164,2,16,3, +0,5,163,2,16,3,0,5,162,2,16,3,0,5,161,2,16,3,0,5,160,2,16,3,0,5,159,2,16,3,0, +5,158,2,16,3,0,5,157,2,16,3,0,5,156,2,16,3,0,5,155,2,16,3,0,5,154,2,16,3,0,5, +153,2,16,3,0,5,152,2,16,3,0,5,151,2,16,3,0,5,150,2,16,3,0,5,149,2,16,3,0,5,148, +2,16,3,0,5,147,2,16,3,0,5,146,2,16,3,0,5,145,2,16,3,0,5,144,2,16,3,0,5,143,2, +16,3,0,5,142,2,16,3,0,5,141,2,16,3,0,5,140,2,16,3,0,5,139,2,16,3,0,5,138,2,16, +3,0,5,137,2,16,3,0,5,136,2,16,3,0,5,135,2,16,3,0,5,134,2,16,3,0,5,133,2,16,3, +0,5,132,2,16,3,0,5,131,2,16,3,0,5,130,2,16,3,0,5,129,2,16,3,0,5,128,2,16,3,0, +5,127,2,16,3,0,5,126,2,16,3,0,5,125,2,16,3,0,5,124,2,16,3,0,5,123,2,16,3,0,5, +122,2,16,3,0,5,121,2,16,3,0,5,120,2,16,3,0,5,119,2,16,3,0,5,118,2,16,3,0,5,117, +2,16,3,0,5,116,2,16,3,0,5,115,2,16,3,0,5,114,2,16,3,0,5,113,2,16,3,0,5,112,2, +16,3,0,5,111,2,16,3,0,5,110,2,16,3,0,5,109,2,16,3,0,5,108,2,16,3,0,5,107,2,16, +3,0,5,106,2,16,3,0,5,105,2,16,3,0,5,104,2,16,3,0,5,103,2,16,3,0,5,102,2,16,3, +0,5,101,2,16,3,0,5,100,2,16,3,0,5,99,2,16,3,0,5,98,2,16,3,0,5,97,2,16,3,0,5, +96,2,16,3,0,5,95,2,16,3,0,5,94,2,16,3,0,5,93,2,16,3,0,5,92,2,16,3,0,5,91,2,16, +3,0,5,90,2,16,3,0,5,89,2,16,3,0,5,88,2,16,3,0,5,87,2,16,3,0,5,86,2,16,3,0,5, +85,2,16,3,0,5,84,2,16,3,0,5,83,2,16,3,0,5,82,2,16,3,0,5,81,2,16,3,0,5,80,2,16, +3,0,5,79,2,16,3,0,5,78,2,16,3,0,5,77,2,16,3,0,5,76,2,16,3,0,5,75,2,16,3,0,5, +74,2,16,3,0,5,73,2,16,3,0,5,72,2,16,3,0,5,71,2,16,3,0,5,70,2,16,3,0,5,69,2,16, +3,0,5,68,2,16,3,0,5,67,2,16,3,0,5,66,2,16,3,0,5,65,2,16,3,0,5,64,2,16,3,0,5, +63,2,16,3,0,5,62,2,16,3,0,5,61,2,16,3,0,5,60,2,16,3,0,5,59,2,16,3,0,5,58,2,16, +58,25,6,0,53,80,5,36,0,208,6,11,0,53,5,9,205,6,9,9,5,2,8,6,53,4,9,53,5,5,52, +4,11,51,11,7,7,141,6,9,9,4,2,8,6,1,1,2,9,6,4,3,7,3,3,2,9,2,17,2,16,21,25,2,0, +16,1,1,2,5,205,6,77,7,5,5,8,4,5,2,8,6,17,2,16,20,25,3,0,15,32,5,2,6,7,51,4,7, +8,51,6,8,9,24,9,17,2,16,25,25,2,0,20,52,3,5,53,3,6,51,6,4,4,1,1,2,8,9,5,3,2, +8,2,17,2,16,85,25,3,0,80,32,4,2,6,7,80,6,18,0,52,6,8,53,6,9,51,9,7,4,5,3,7,8, +3,2,7,2,80,7,37,0,53,7,8,80,8,15,0,1,1,3,9,7,3,4,3,3,9,7,4,2,9,2,52,7,9,1,1, +2,4,5,3,7,9,3,2,7,2,1,1,2,4,5,3,7,5,3,2,7,2,17,2,16,3,0,5,57,2,16,3,0,5,56,2, +16,3,0,5,55,2,16,3,0,5,54,2,16,3,0,5,53,2,16,3,0,5,52,2,16,3,0,5,51,2,16,3,0, +5,50,2,16,3,0,5,49,2,16,3,0,5,48,2,16,3,0,5,47,2,16,3,0,5,46,2,16,3,0,5,45,2, +16,3,0,5,44,2,16,3,0,5,43,2,16,3,0,5,42,2,16,3,0,5,41,2,16,3,0,5,40,2,16,3,0, +5,39,2,16,57,25,1,0,52,208,3,39,0,1,1,3,4,1,1,2,5,34,4,5,6,208,6,14,0,1,2,2, +7,1,1,4,3,9,6,4,2,7,2,1,1,4,7,205,3,2,7,1,1,1,4,4,205,3,2,4,1,17,2,16,41,25, +1,0,36,1,1,2,4,52,4,5,53,5,6,51,3,6,7,53,4,8,51,7,8,9,1,1,3,10,51,10,9,3,1,1, +4,12,2,12,1,17,2,16,97,25,1,0,92,208,3,44,0,1,1,4,4,1,1,2,5,51,4,5,6,1,2,2,7, +1,1,6,8,1,1,7,9,4,5,2,4,8,6,9,3,1,1,5,11,5,4,5,11,4,2,7,3,1,1,6,4,52,4,5,1,2, +2,6,1,1,2,7,1,1,3,8,1,1,7,9,3,7,2,3,7,4,8,5,9,3,1,1,4,4,1,1,5,5,2,6,3,17,2,16, +53,25,1,0,48,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,1,1,5,8,1,1,6,9,3,8,2,3,5,6,7,3, +8,9,10,5,4,8,3,5,5,7,4,10,3,2,8,3,17,2,16,37,25,5,0,32,80,4,16,0,1,1,2,8,6,7, +3,5,7,6,4,3,3,2,8,2,51,6,5,8,77,9,51,8,9,10,24,10,17,2,16,31,25,1,0,26,1,1,2, +4,14,1,5,40,4,5,6,7,1,1,4,5,1,1,3,3,9,6,4,2,5,3,17,2,16,35,25,1,0,30,37,3,4, +208,4,14,0,1,2,2,5,1,1,2,3,14,0,4,2,5,2,1,1,2,5,205,3,2,5,1,17,2,16,76,25,1, +0,71,208,3,32,0,1,2,4,4,1,1,4,5,3,3,2,5,5,6,14,10,7,1,1,2,5,9,4,9,5,6,3,7,4, +2,9,3,1,2,2,4,1,1,2,5,1,1,4,6,1,1,3,7,4,5,2,3,5,6,7,3,14,1,9,5,4,7,9,4,2,7,2, +17,2,16,28,25,1,0,23,1,1,2,4,53,4,5,1,1,4,6,1,1,3,3,5,5,4,6,5,2,5,3,17,2,16, +44,25,1,0,39,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,4,5,2,3,5,6,7,8,1,2,4,5,9,4,10, +5,3,4,8,3,2,10,3,17,2,16,25,25,3,0,20,80,4,14,0,1,1,2,6,6,5,3,4,3,5,3,2,6,2, +24,4,17,2,16,37,25,1,0,32,1,1,2,4,53,4,5,1,2,2,6,1,1,3,7,1,1,4,8,4,4,2,3,7,8, +3,9,5,4,2,6,2,17,2,16,37,25,1,0,32,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,3,5,2,3,5, +6,7,3,5,4,7,5,4,2,7,2,17,2,16,77,25,1,0,72,208,3,36,0,1,2,4,4,1,1,3,5,1,1,4, +6,4,4,2,5,5,6,7,1,1,2,8,5,4,9,3,5,5,7,3,8,4,2,9,3,1,2,2,4,1,1,2,5,1,1,3,6,1, +1,4,7,3,5,2,3,5,6,7,3,5,4,7,5,4,2,7,2,17,2,16,37,25,3,0,32,80,4,14,0,1,1,4,6, +6,5,5,4,3,5,3,2,6,1,1,1,2,6,6,5,3,4,3,5,3,2,6,1,17,2,16,27,25,1,0,22,1,2,2,4, +1,1,2,5,14,1,6,9,4,7,5,5,3,6,4,2,7,2,17,2,16,17,25,1,0,12,1,1,2,4,6,3,3,3,3, +2,4,1,17,2,16,3,0,5,38,2,16,3,0,5,37,2,16,3,0,5,36,2,16,3,0,5,35,2,16,3,0,5, +34,2,16,3,0,5,33,2,16,3,0,5,32,2,16,3,0,5,31,2,16,3,0,5,30,2,16,3,0,5,29,2,16, +3,0,5,28,2,16,3,0,5,27,2,16,3,0,5,26,2,16,3,0,5,25,2,16,3,0,5,24,2,16,3,0,5, +23,2,16,36,89,2,0,31,1,1,2,6,6,4,3,4,3,7,1,1,4,4,1,1,5,9,5,6,10,5,6,5,7,3,9, +5,2,10,4,17,2,16,3,0,5,22,2,16,61,25,2,0,19,1,1,2,5,1,1,3,6,9,5,8,5,4,5,6,4, +2,8,3,89,1,0,33,1,1,4,5,6,3,5,3,6,1,1,6,7,1,1,7,8,9,5,9,5,6,3,4,6,5,7,4,8,5, +2,9,4,17,2,16,3,0,5,21,2,16,3,0,5,20,2,16,34,25,2,0,29,28,4,5,1,1,2,6,14,0,7, +14,1,8,9,6,10,5,4,6,7,4,5,5,7,8,5,2,10,5,17,2,16,28,25,1,0,23,1,2,2,4,1,1,2, +5,1,2,3,6,9,4,7,5,5,3,6,4,2,7,2,17,2,16,34,25,2,0,29,28,4,5,1,1,2,6,14,0,7,14, +2,8,9,6,10,5,4,6,7,4,5,5,7,8,5,2,10,5,17,2,16,14,25,2,0,9,14,1,5,47,4,5,6,24, +6,17,2,16,3,0,5,19,2,16,3,0,5,18,2,16,3,0,5,17,2,16,3,0,5,16,2,16,3,0,5,15,2, +16,3,0,5,14,2,16,3,0,5,13,2,16,3,0,5,12,2,16,3,0,5,11,2,16,3,0,5,10,2,16,3,0, +5,9,2,16,3,0,5,8,2,16,3,0,5,7,2,16,3,0,5,6,2,16,3,0,5,5,2,16,3,0,5,4,2,16,3, +0,5,3,2,16,3,0,5,2,2,16,3,0,5,1,2,16,3,0,5,0,2,16,3,0,4,255,2,16,3,0,4,254,2, +16,3,0,4,253,2,16,3,0,4,252,2,16,3,0,4,251,2,16,3,0,4,250,2,16,3,0,4,249,2,16, +3,0,4,248,2,16,26,25,1,0,21,1,1,3,4,1,1,2,5,205,6,9,4,7,5,5,3,6,4,2,7,2,17,2, +16,43,25,1,0,38,1,2,2,4,1,1,2,5,1,1,3,6,3,4,2,3,5,6,7,1,2,4,8,77,5,5,4,10,3, +6,5,7,3,8,4,2,10,4,17,2,16,3,0,4,247,2,16,3,0,4,246,2,16,3,0,4,245,2,16,3,0, +4,244,2,16,3,0,4,243,2,16,3,0,4,242,2,16,3,0,4,241,2,16,3,0,4,240,2,16,3,0,4, +239,2,16,3,0,4,238,2,16,3,0,4,237,2,16,3,0,4,236,2,16,3,0,4,235,2,16,3,0,4,234, +2,16,3,0,4,233,2,16,3,0,4,232,2,16,3,0,4,231,2,16,3,0,4,230,2,16,3,0,4,229,2, +16,3,0,4,228,2,16,3,0,4,227,2,16,3,0,4,226,2,16,3,0,4,225,2,16,3,0,4,224,2,16, +3,0,4,223,2,16,3,0,4,222,2,16,3,0,4,221,2,16,3,0,4,220,2,16,3,0,4,219,2,16,3, +0,4,218,2,16,3,0,4,217,2,16,3,0,4,216,2,16,3,0,4,215,2,16,3,0,4,214,2,16,3,0, +4,213,2,16,3,0,4,212,2,16,3,0,4,211,2,16,3,0,4,210,2,16,3,0,4,209,2,16,3,0,4, +208,2,16,3,0,4,207,2,16,3,0,4,206,2,16,3,0,4,205,2,16,3,0,4,204,2,16,3,0,4,203, +2,16,3,0,4,202,2,16,3,0,4,201,2,16,3,0,4,200,2,16,3,0,4,199,2,16,3,0,4,198,2, +16,3,0,4,197,2,16,3,0,4,196,2,16,3,0,4,195,2,16,3,0,4,194,2,16,3,0,4,193,2,16, +3,0,4,192,2,16,3,0,4,191,2,16,3,0,4,190,2,16,3,0,4,189,2,16,3,0,4,188,2,16,3, +0,4,187,2,16,3,0,4,186,2,16,3,0,4,185,2,16,3,0,4,184,2,16,3,0,4,183,2,16,3,0, +4,182,2,16,3,0,4,181,2,16,3,0,4,180,2,16,3,0,4,179,2,16,3,0,4,178,2,16,3,0,4, +177,2,16,3,0,4,176,2,16,3,0,4,175,2,16,3,0,4,174,2,16,3,0,4,173,2,16,3,0,4,172, +2,16,3,0,4,171,2,16,3,0,4,170,2,16,3,0,4,169,2,16,3,0,4,168,2,16,3,0,4,167,2, +16,3,0,4,166,2,16,3,0,4,165,2,16,3,0,4,164,2,16,3,0,4,163,2,16,3,0,4,162,2,16, +3,0,4,161,2,16,3,0,4,160,2,16,3,0,4,159,2,16,3,0,4,158,2,16,3,0,4,157,2,16,3, +0,4,156,2,16,3,0,4,155,2,16,3,0,4,154,2,16,3,0,4,153,2,16,3,0,4,152,2,16,3,0, +4,151,2,16,3,0,4,150,2,16,3,0,4,149,2,16,3,0,4,148,2,16,3,0,4,147,2,16,3,0,4, +146,2,16,3,0,4,145,2,16,3,0,4,144,2,16,3,0,4,143,2,16,3,0,4,142,2,16,3,0,4,141, +2,16,3,0,4,140,2,16,3,0,4,139,2,16,3,0,4,138,2,16,3,0,4,137,2,16,3,0,4,136,2, +16,3,0,4,135,2,16,3,0,4,134,2,16,3,0,4,133,2,16,3,0,4,132,2,16,3,0,4,131,2,16, +3,0,4,130,2,16,3,0,4,129,2,16,3,0,4,128,2,16,3,0,4,127,2,16,27,25,1,0,22,1,2, +2,4,1,1,2,5,14,42,6,9,4,7,5,5,3,6,4,2,7,2,17,2,16,25,25,4,0,20,1,1,2,7,6,3,3, +3,3,1,1,4,4,1,1,5,5,2,7,3,17,2,16,3,0,4,126,2,16,48,25,1,0,43,1,2,2,4,1,1,2, +5,1,1,3,6,1,1,4,7,1,1,5,8,3,6,2,3,5,6,7,8,9,14,1,5,9,4,8,5,3,4,9,3,2,8,3,17, +2,16,3,0,4,125,2,16,3,0,4,124,2,16,19,25,1,0,14,1,1,2,4,141,5,5,4,7,5,4,2,7, +2,17,2,16,19,25,1,0,14,1,1,2,4,205,5,5,4,7,5,4,2,7,2,17,2,16,12,25,1,0,7,1,1, +2,4,2,4,1,17,2,16,35,25,1,0,30,1,2,2,4,1,1,2,5,1,1,3,6,4,4,2,3,5,6,7,9,4,8,5, +3,4,7,3,2,8,2,17,2,16,37,25,1,0,32,1,1,2,4,1,1,4,5,1,1,5,6,4,4,2,2,5,6,7,23, +2,1,4,7,4,1,1,3,9,2,9,2,17,2,16,43,25,1,0,38,1,2,2,4,1,1,4,5,4,3,2,3,5,6,1,1, +3,7,1,1,2,5,9,4,9,5,6,10,3,6,5,7,4,10,3,2,9,4,17,2,16,46,25,1,0,41,1,2,2,4,1, +1,2,5,1,1,3,6,1,1,4,7,1,1,5,8,3,7,2,3,5,3,6,7,8,9,9,4,7,5,3,4,9,3,2,7,2,17,2, +16,22,25,4,0,17,1,1,2,7,6,6,3,6,5,4,3,3,205,6,2,7,4,17,2,16,121,25,2,0,116,208, +4,58,0,1,1,2,5,51,4,5,6,1,1,3,7,53,7,8,1,1,8,9,1,1,7,10,1,1,6,11,1,1,5,12,1, +1,4,13,5,6,4,3,6,5,8,7,10,3,5,9,10,11,5,5,12,8,13,9,2,10,8,1,1,3,5,53,5,6,1, +1,8,7,1,1,7,8,1,1,2,9,1,1,6,10,1,1,5,11,1,1,4,12,5,10,5,7,10,5,6,7,3,6,5,8,3, +9,4,5,11,8,12,9,2,10,8,17,2,16,51,25,8,0,46,80,7,29,0,52,7,11,1,1,2,12,7,9,3, +4,7,9,8,5,3,10,3,9,6,4,5,8,6,11,5,2,12,4,5,6,7,5,6,5,4,5,9,4,2,4,5,17,2,16,37, +25,1,0,32,1,1,5,4,1,1,4,5,1,1,3,6,1,1,2,7,9,5,10,5,6,5,7,6,5,3,7,10,3,2,4,5, +17,2,16,56,25,1,0,51,1,2,2,4,1,1,7,5,1,1,6,6,1,1,5,7,1,1,4,8,1,1,3,9,1,1,2,10, +5,4,12,6,4,5,3,6,5,3,5,7,5,8,7,5,9,8,10,9,2,12,7,17,2,16,70,25,1,0,65,1,2,2, +4,1,1,3,5,1,1,4,6,1,1,5,7,1,1,6,8,1,1,7,9,1,1,8,10,1,1,9,11,3,9,2,3,5,6,7,8, +9,10,11,12,1,1,2,13,1,2,4,5,5,4,9,3,6,5,12,3,13,4,2,9,4,17,2,16,46,25,4,0,41, +80,4,35,0,52,4,7,14,1,8,47,7,8,9,8,9,5,15,0,52,4,10,53,4,4,7,4,2,10,3,3,2,6, +4,53,4,10,24,10,24,4,17,2,16,59,25,1,0,54,1,2,2,4,1,1,7,5,1,1,6,6,1,1,5,7,1, +1,4,8,1,1,3,9,1,1,2,10,9,4,12,5,5,13,3,5,5,6,4,7,6,5,8,7,9,8,5,10,9,13,3,2,12, +7,17,2,16,55,25,1,0,50,1,2,2,4,1,1,3,5,1,1,4,6,1,1,5,7,1,1,6,8,1,1,7,9,3,8,2, +3,5,6,7,8,3,9,3,1,1,2,11,9,4,8,5,7,5,11,4,2,8,3,17,2,16,30,25,7,0,25,1,1,2,10, +6,8,3,6,9,8,4,7,3,3,9,5,8,5,4,5,8,4,2,10,3,17,2,16,20,25,2,0,15,1,1,2,5,51,5, +4,4,1,1,3,7,2,7,2,17,2,16,57,25,4,0,52,80,4,38,0,52,4,7,14,1,8,47,7,8,9,8,5, +9,12,0,53,4,4,7,4,2,7,3,3,2,6,4,53,4,4,5,3,8,7,3,2,8,2,205,7,5,3,8,7,3,2,8,2, +17,2,16,26,25,9,0,21,23,2,1,4,5,12,51,12,9,6,9,8,5,5,10,7,11,4,2,4,5,17,2,16, +45,25,9,0,40,1,1,3,12,23,2,3,12,5,6,7,13,23,2,1,4,13,14,1,1,2,15,5,4,7,8,4,5, +9,5,10,6,5,11,9,14,8,2,15,7,17,2,16,46,25,1,0,41,1,1,2,4,77,5,51,4,5,6,1,2,2, +7,1,1,4,8,1,1,5,9,3,4,2,3,8,9,10,1,1,3,5,5,3,4,10,3,2,7,4,17,2,16,88,25,3,0, +83,1,2,2,6,8,5,6,42,0,1,2,7,7,8,5,7,18,0,1,2,10,8,4,4,2,11,4,3,3,1,2,12,4,2, +8,2,1,2,8,8,1,1,3,5,1,2,9,6,2,8,4,1,2,3,7,1,1,2,8,1,1,3,9,3,6,2,4,8,9,4,3,3, +1,2,5,5,1,2,6,6,2,7,4,17,2,16,61,25,9,0,56,52,6,12,23,2,1,12,7,13,7,4,5,12,5, +14,23,2,1,4,14,15,51,15,8,16,51,13,16,17,53,6,5,1,1,2,19,7,6,3,9,17,3,11,3,6, +4,4,4,12,6,9,10,4,2,19,4,17,2,16,55,25,1,0,50,1,2,2,4,1,1,4,5,1,1,5,6,1,1,6, +7,1,1,7,8,4,6,2,3,5,6,7,8,9,1,1,3,10,1,1,2,5,5,4,12,3,6,5,9,3,10,4,2,12,4,17, +2,16,21,25,1,0,16,1,1,2,4,1,2,2,5,5,4,7,5,4,2,7,2,17,2,16,80,25,1,0,75,1,1,4, +4,1,1,9,5,3,3,2,5,5,6,23,2,1,4,6,7,1,1,2,8,51,7,8,9,1,2,2,10,1,1,5,11,1,1,6, +12,1,1,7,13,1,1,8,14,3,8,2,3,4,11,12,9,13,14,15,1,2,4,4,1,1,3,6,5,3,5,15,3,2, +10,4,17,2,16,33,25,9,0,28,1,1,2,12,6,10,3,8,6,4,10,9,3,11,5,3,1,1,4,6,5,4,5, +10,4,2,12,4,17,2,16,43,25,1,0,38,1,1,4,4,4,4,2,3,3,4,5,1,1,3,6,80,6,5,0,205, +3,2,5,1,1,2,2,7,1,1,2,4,9,5,3,2,7,2,17,2,16,33,25,9,0,28,6,5,2,9,8,5,12,23,2, +1,4,12,13,51,13,8,5,9,9,6,5,10,7,11,4,2,4,5,17,2,16,79,25,2,0,74,208,4,38,0, +1,1,2,5,52,5,6,53,5,7,51,4,7,8,51,6,8,5,1,1,5,4,1,1,4,11,1,1,3,6,5,3,7,11,3, +2,4,5,1,1,5,5,1,1,4,6,1,1,2,7,1,1,3,8,9,5,4,5,7,5,3,7,5,6,3,8,6,2,4,5,17,2,16, +49,25,9,0,44,6,3,4,5,12,23,2,1,4,12,13,51,13,8,14,23,2,1,4,7,15,1,1,2,16,7,6, +3,14,9,3,11,3,9,6,5,5,10,4,15,6,2,16,4,17,2,16,37,25,1,0,32,1,1,5,4,1,1,4,5, +1,1,3,6,1,1,2,7,9,3,9,5,4,3,5,4,5,6,5,7,6,2,9,4,17,2,16,54,25,1,0,49,1,1,2,4, +51,4,3,5,1,2,2,6,1,1,3,7,1,1,4,4,1,1,5,9,4,6,2,3,7,4,5,9,3,1,2,4,5,1,2,5,12, +5,6,9,12,6,2,9,4,17,2,16,31,25,9,0,26,23,2,1,4,5,12,1,1,2,13,6,6,3,12,11,10, +3,3,5,8,4,9,5,2,13,3,17,2,16,18,25,9,0,13,77,12,9,6,5,5,11,4,12,6,2,4,5,17,2, +16,42,25,9,0,37,7,3,5,5,12,23,2,1,4,12,13,51,13,8,14,1,1,2,15,7,6,3,9,14,3,11, +3,1,1,4,5,9,10,4,2,15,4,17,2,16,129,51,25,2,0,174,208,3,66,0,1,1,4,5,1,1,9,6, +4,4,2,7,3,6,7,23,2,1,5,7,8,1,1,3,9,51,8,9,10,1,2,5,11,1,1,6,12,1,1,7,13,1,1, +8,14,4,6,2,6,12,10,13,14,3,1,1,5,16,5,4,6,16,4,2,11,4,1,1,2,5,208,5,47,0,1,1, +4,6,1,1,9,7,4,3,2,4,7,8,23,2,1,6,8,9,1,1,3,10,51,9,10,5,1,1,8,4,1,1,7,3,1,1, +6,6,1,1,5,7,2,4,5,1,2,2,6,1,1,6,7,1,1,3,8,1,1,7,9,1,1,8,10,4,6,2,3,7,8,9,10, +3,1,1,5,4,1,1,4,5,1,1,9,14,5,6,9,14,6,2,9,4,17,2,16,67,25,1,0,62,1,2,2,4,1,1, +2,5,1,1,3,6,1,1,4,7,1,1,5,8,1,1,6,9,1,1,7,10,1,1,8,11,1,1,9,12,3,10,2,3,5,6, +7,8,9,10,11,12,13,205,5,9,4,8,5,3,4,13,3,2,8,3,17,2,16,33,25,9,0,28,1,1,2,12, +6,10,3,7,8,4,10,9,3,11,5,3,1,1,4,6,5,4,5,10,4,2,12,4,17,2,16,74,25,1,0,69,1, +2,3,4,1,2,4,5,1,1,3,6,1,1,2,7,23,2,3,4,5,6,7,8,1,1,5,9,23,2,1,9,8,10,1,2,2,11, +1,1,9,3,1,1,8,4,1,1,7,5,1,1,6,6,1,1,4,16,9,9,7,5,10,8,16,9,2,11,7,17,2,16,28, +25,9,0,23,1,1,2,12,6,10,3,7,6,11,4,10,9,8,3,3,1,1,4,4,2,12,2,17,2,16,26,25,1, +0,21,1,2,2,4,1,1,2,5,23,2,1,4,5,4,1,1,3,7,2,7,2,17,2,16,48,25,2,0,43,1,1,2,5, +1,1,7,6,3,3,2,2,6,7,23,2,1,5,7,8,1,1,3,9,51,8,9,5,1,1,6,4,1,1,5,6,1,1,4,7,2, +4,5,17,2,16,42,25,9,0,37,6,8,3,4,8,10,9,11,5,12,7,4,2,12,5,13,23,2,1,4,13,14, +51,14,8,5,9,9,6,5,10,7,11,4,2,4,5,17,2,16,47,25,2,0,42,1,1,2,5,1,1,6,6,4,4,2, +2,3,6,7,23,2,1,5,7,8,51,8,4,4,1,1,5,10,1,1,4,3,77,5,1,1,3,6,2,10,4,17,2,16,58, +25,9,0,53,208,6,22,0,1,1,3,12,6,8,4,7,4,10,3,11,5,3,5,8,4,9,5,2,12,3,6,3,2,5, +12,23,2,1,4,12,13,51,7,8,14,51,13,14,4,5,9,5,10,6,2,11,4,17,2,16,24,25,1,0,19, +1,1,3,4,1,1,2,5,51,4,5,4,1,1,4,7,2,7,2,17,2,16,54,25,1,0,49,1,1,7,4,1,1,8,5, +4,5,2,2,3,4,5,6,23,2,1,4,6,7,1,1,2,8,51,7,8,5,1,1,6,4,1,1,5,3,1,1,4,6,1,1,3, +7,2,4,5,17,2,16,69,25,1,0,64,1,2,2,4,1,1,3,5,1,1,4,6,1,1,5,7,1,1,6,8,1,1,7,9, +1,1,8,10,1,1,9,11,3,9,2,3,5,6,7,8,9,10,11,12,1,1,2,13,9,4,9,5,3,5,7,6,5,12,3, +13,4,2,9,4,17,2,16,18,25,3,0,13,14,1,6,47,5,6,7,51,7,4,8,24,8,17,2,16,35,25, +9,0,30,1,1,4,12,1,1,2,13,6,10,3,12,8,10,9,3,11,4,5,3,77,5,5,8,6,12,4,2,13,4, +17,2,16,43,25,9,0,38,7,4,5,6,5,12,23,2,1,4,12,13,51,13,8,14,1,1,2,15,7,6,3,9, +14,3,11,3,1,1,4,5,9,10,4,2,15,4,17,2,16,31,25,9,0,26,6,3,2,5,12,23,2,1,4,12, +13,51,13,8,5,9,9,6,5,10,7,11,4,2,4,5,17,2,16,70,25,1,0,65,1,1,2,4,1,1,8,5,4, +4,2,5,3,5,6,23,2,1,4,6,7,1,1,3,8,51,7,8,9,1,2,2,10,1,1,5,11,1,1,6,12,1,1,7,13, +4,6,2,3,11,9,12,13,3,1,1,4,4,1,2,4,5,2,10,3,17,2,16,61,25,1,0,56,1,2,2,4,1,1, +3,5,1,1,4,6,1,1,5,7,1,1,6,8,1,1,7,9,1,1,8,10,3,9,2,3,5,6,7,8,9,3,10,3,1,1,2, +12,1,2,4,5,5,4,8,12,4,2,8,3,17,2,16,62,25,1,0,57,1,2,2,4,1,1,2,5,1,1,3,6,1,1, +4,7,1,1,5,8,1,1,6,9,1,1,7,10,3,9,2,3,3,5,6,7,8,9,10,11,1,2,4,5,205,6,9,4,9,5, +3,4,11,3,2,9,4,17,2,16,31,25,9,0,26,1,1,2,12,6,8,3,4,8,10,9,3,5,3,1,1,4,5,205, +6,9,10,4,2,12,4,17,2,16,27,25,2,0,22,1,1,2,5,1,1,3,6,14,0,7,9,5,9,5,6,5,7,6, +2,9,4,17,2,16,51,25,1,0,46,208,3,31,0,1,1,2,4,14,1,5,47,4,5,6,1,1,5,7,1,1,4, +3,1,1,3,5,5,6,4,7,6,2,6,4,1,1,4,4,1,1,3,3,2,4,1,17,2,16,57,25,1,0,52,208,3,11, +0,1,1,4,4,1,1,2,3,2,4,1,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,1,1,5,8,4,6,2,3,5,6, +7,8,3,5,4,7,5,4,2,7,2,17,2,16,43,25,1,0,38,1,2,2,4,1,1,3,5,4,3,2,3,5,6,1,1,2, +7,1,2,4,5,9,4,9,5,6,10,3,6,5,7,4,10,3,2,9,4,17,2,16,45,25,1,0,40,1,2,2,4,1,1, +4,5,1,1,5,6,3,4,2,3,5,6,7,1,1,3,8,1,1,2,5,5,4,10,3,6,5,7,3,8,4,2,10,4,17,2,16, +44,25,1,0,39,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,3,6,2,3,5,3,6,7,8,14,0,6,9,4,10, +5,3,4,8,3,2,10,4,17,2,16,44,25,1,0,39,1,2,2,4,1,1,2,5,1,1,3,6,3,5,2,3,3,5,6, +7,1,2,4,8,205,6,5,4,10,5,4,5,7,3,8,5,2,10,4,17,2,16,60,25,1,0,55,208,3,40,0, +1,1,2,4,36,4,5,47,4,5,6,1,2,2,7,1,1,3,8,1,1,4,9,3,4,2,3,8,9,3,1,2,4,5,9,6,4, +2,7,3,1,1,4,4,1,1,3,3,2,4,1,17,2,16,55,25,1,0,50,1,2,2,4,1,1,3,5,1,1,4,6,1,1, +5,7,1,1,6,8,4,6,2,3,5,6,7,8,9,1,1,2,10,1,2,4,5,5,4,12,3,6,5,9,3,10,4,2,12,4, +17,2,16,110,25,4,0,105,14,1,7,8,3,7,60,0,1,2,2,8,47,8,3,9,1,1,7,10,1,1,6,11, +1,1,5,12,1,1,4,13,1,1,3,14,1,1,2,15,5,9,16,6,7,5,5,6,4,5,5,10,3,11,4,5,12,8, +13,9,5,14,10,15,11,2,16,9,1,1,6,8,23,2,1,8,4,9,1,1,4,10,51,9,10,6,1,1,2,4,1, +1,7,3,1,1,5,5,1,1,3,7,2,4,5,17,2,16,55,25,1,0,50,1,2,2,4,1,1,3,5,1,1,4,6,1,1, +5,7,1,1,6,8,1,1,7,9,3,8,2,3,5,3,6,7,8,9,3,1,1,2,11,14,0,5,5,4,8,11,4,2,8,3,17, +2,16,65,25,5,0,60,80,5,32,0,32,5,2,8,9,32,8,2,10,11,1,1,3,12,6,8,4,11,4,6,9, +10,3,3,5,7,4,11,5,2,12,3,80,6,10,0,77,8,5,6,5,8,6,2,4,5,1,1,2,8,9,7,4,2,8,2, +17,2,16,51,25,9,0,46,1,1,7,12,6,3,6,5,13,23,2,1,4,13,14,51,14,8,15,1,1,2,16, +6,7,3,10,9,15,3,12,3,1,1,4,4,1,1,5,5,9,11,6,2,16,4,17,2,16,35,25,1,0,30,1,2, +2,4,1,1,3,5,1,1,2,6,77,7,9,5,10,5,6,5,7,6,5,3,7,10,3,2,4,5,17,2,16,3,0,4,123, +2,16,25,25,1,0,20,61,4,5,1,1,2,6,6,4,3,5,3,3,1,1,4,5,2,6,3,17,2,16,3,0,4,122, +2,16,3,0,4,121,2,16,3,0,4,120,2,16,3,0,4,119,2,16,3,0,4,118,2,16,3,0,4,117,2, +16,3,0,4,116,2,16,3,0,4,115,2,16,3,0,4,114,2,16,3,0,4,113,2,16,3,0,4,112,2,16, +3,0,4,111,2,16,3,0,4,110,2,16,3,0,4,109,2,16,3,0,4,108,2,16,3,0,4,107,2,16,3, +0,4,106,2,16,3,0,4,105,2,16,3,0,4,104,2,16,3,0,4,103,2,16,3,0,4,102,2,16,3,0, +4,101,2,16,3,0,4,100,2,16,3,0,4,99,2,16,3,0,4,98,2,16,3,0,4,97,2,16,3,0,4,96, +2,16,3,0,4,95,2,16,3,0,4,94,2,16,3,0,4,93,2,16,3,0,4,92,2,16,3,0,4,91,2,16,3, +0,4,90,2,16,3,0,4,89,2,16,3,0,4,88,2,16,3,0,4,87,2,16,3,0,4,86,2,16,3,0,4,85, +2,16,3,0,4,84,2,16,3,0,4,83,2,16,3,0,4,82,2,16,3,0,4,81,2,16,3,0,4,80,2,16,3, +0,4,79,2,16,3,0,4,78,2,16,3,0,4,77,2,16,3,0,4,76,2,16,3,0,4,75,2,16,3,0,4,74, +2,16,3,0,4,73,2,16,3,0,4,72,2,16,3,0,4,71,2,16,3,0,4,70,2,16,3,0,4,69,2,16,3, +0,4,68,2,16,3,0,4,67,2,16,3,0,4,66,2,16,3,0,4,65,2,16,3,0,4,64,2,16,3,0,4,63, +2,16,3,0,4,62,2,16,3,0,4,61,2,16,3,0,4,60,2,16,3,0,4,59,2,16,3,0,4,58,2,16,3, +0,4,57,2,16,3,0,4,56,2,16,3,0,4,55,2,16,3,0,4,54,2,16,3,0,4,53,2,16,3,0,4,52, +2,16,3,0,4,51,2,16,3,0,4,50,2,16,3,0,4,49,2,16,3,0,4,48,2,16,3,0,4,47,2,16,3, +0,4,46,2,16,3,0,4,45,2,16,3,0,4,44,2,16,3,0,4,43,2,16,3,0,4,42,2,16,3,0,4,41, +2,16,3,0,4,40,2,16,3,0,4,39,2,16,3,0,4,38,2,16,3,0,4,37,2,16,3,0,4,36,2,16,3, +0,4,35,2,16,3,0,4,34,2,16,3,0,4,33,2,16,3,0,4,32,2,16,3,0,4,31,2,16,3,0,4,30, +2,16,3,0,4,29,2,16,3,0,4,28,2,16,3,0,4,27,2,16,3,0,4,26,2,16,3,0,4,25,2,16,3, +0,4,24,2,16,3,0,4,23,2,16,3,0,4,22,2,16,3,0,4,21,2,16,3,0,4,20,2,16,3,0,4,19, +2,16,3,0,4,18,2,16,3,0,4,17,2,16,3,0,4,16,2,16,3,0,4,15,2,16,3,0,4,14,2,16,3, +0,4,13,2,16,3,0,4,12,2,16,3,0,4,11,2,16,3,0,4,10,2,16,35,25,1,0,30,1,2,2,4,1, +1,3,5,1,1,2,6,77,7,9,4,9,5,3,4,5,3,5,6,5,7,6,2,9,4,17,2,16,59,25,1,0,54,208, +3,19,0,1,2,5,4,1,1,3,5,9,4,7,5,3,4,5,3,2,7,2,1,2,2,4,1,1,2,5,1,1,3,6,4,4,2,3, +5,6,3,1,2,4,8,5,4,9,8,4,2,9,2,17,2,16,35,25,2,0,30,1,2,2,5,1,1,2,6,4,4,2,3,3, +6,3,1,2,4,8,9,5,9,5,4,5,8,4,2,9,3,17,2,16,31,25,1,0,26,1,1,3,4,1,1,4,5,3,3,2, +2,5,3,1,1,2,7,5,4,8,7,4,2,8,2,17,2,16,28,25,1,0,23,1,2,2,4,1,1,2,5,1,1,3,6,3, +5,2,3,5,6,3,3,2,4,1,17,2,16,67,25,2,0,62,1,2,3,5,1,1,2,6,3,4,2,7,4,6,7,23,2, +1,5,7,8,77,9,51,8,9,4,1,2,5,11,1,2,6,12,51,11,12,13,1,2,4,14,51,5,14,15,51,15, +9,16,51,13,16,5,1,2,2,18,2,18,3,17,2,16,41,25,1,0,36,1,2,2,4,1,1,2,5,1,1,3,6, +1,1,4,7,3,5,2,3,5,6,7,3,1,2,4,9,5,4,7,9,4,2,7,2,17,2,16,16,25,1,0,11,1,1,2,4, +1,2,2,3,2,4,1,17,2,16,3,0,4,9,2,16,3,0,4,8,2,16,3,0,4,7,2,16,3,0,4,6,2,16,3, +0,4,5,2,16,3,0,4,4,2,16,3,0,4,3,2,16,3,0,4,2,2,16,3,0,4,1,2,16,34,25,3,0,29, +1,1,2,6,6,4,3,5,3,7,1,1,4,5,1,1,5,9,9,6,10,5,7,3,9,6,2,10,4,17,2,16,3,0,4,0, +2,16,40,25,1,0,35,1,2,2,4,1,1,3,5,1,1,4,6,3,4,2,3,5,6,3,1,1,2,8,1,2,4,5,5,4, +10,8,4,2,10,3,17,2,16,129,4,25,1,0,127,208,3,40,0,1,2,8,4,1,1,4,5,1,1,5,6,1, +1,6,7,3,5,2,9,5,6,7,3,1,1,2,9,1,1,3,5,5,4,11,9,4,2,11,3,1,1,3,4,208,4,44,0,1, +2,5,5,1,1,4,6,1,1,6,7,1,1,2,8,3,6,2,6,6,7,8,4,3,1,1,5,4,1,2,7,11,9,5,12,5,6, +5,11,6,2,12,4,1,2,2,5,1,1,2,6,1,1,5,7,1,1,6,8,3,5,2,3,6,7,8,3,1,2,4,4,2,5,2, +17,2,16,118,25,1,0,113,80,3,64,0,1,2,4,4,1,1,2,5,1,1,3,6,1,1,4,7,1,1,5,8,1,1, +6,9,1,1,7,10,1,1,8,11,3,10,2,5,5,6,7,8,3,9,10,11,3,1,2,6,13,1,2,7,6,9,4,9,5, +5,4,13,5,2,9,4,1,2,2,4,1,1,6,5,1,1,7,6,1,1,8,7,1,1,4,8,4,6,2,3,5,6,7,8,3,1,1, +2,10,1,1,3,5,5,4,8,10,4,2,8,3,17,2,16,28,25,7,0,23,1,1,2,10,6,9,3,6,7,9,8,5, +4,3,3,5,6,4,7,5,2,10,3,17,2,16,75,25,1,0,70,1,2,3,4,1,1,4,5,1,1,3,6,1,1,2,7, +23,2,3,4,5,6,7,8,1,1,6,9,23,2,1,9,8,10,1,2,2,11,1,1,9,12,1,1,8,4,1,1,7,5,1,1, +5,15,9,3,6,5,9,7,10,8,5,12,3,15,9,2,11,7,17,2,16,35,25,9,0,30,1,1,2,12,6,10, +3,7,6,5,11,4,9,8,3,3,1,1,4,5,1,1,5,6,9,10,4,2,12,4,17,2,16,53,25,1,0,48,1,1, +2,4,1,1,8,5,4,4,2,2,3,5,6,23,2,1,4,6,7,1,1,3,8,51,7,8,5,1,1,7,4,1,1,6,3,1,1, +5,6,1,1,4,7,2,4,5,17,2,16,65,25,1,0,60,1,2,2,4,1,1,2,5,1,1,3,6,1,1,4,7,1,1,5, +8,1,1,6,9,1,1,7,10,1,1,8,11,3,10,2,3,3,5,6,7,8,9,10,11,3,1,2,4,13,9,4,9,5,8, +5,13,4,2,9,3,17,2,16,30,25,9,0,25,1,1,2,12,6,9,3,4,8,10,9,3,11,5,3,1,1,4,4,9, +8,5,2,12,3,17,2,16,54,25,9,0,49,6,4,4,6,5,12,23,2,1,4,12,13,51,13,8,5,1,1,3, +15,23,2,1,15,4,16,23,2,1,6,16,8,1,1,2,18,5,6,4,9,6,5,10,7,11,9,2,18,7,17,2,16, +33,25,9,0,28,23,2,2,5,6,7,12,23,2,1,4,12,13,51,13,8,5,9,9,6,5,10,7,11,4,2,4, +5,17,2,16,50,25,2,0,45,80,3,32,0,1,1,2,5,51,4,5,6,1,1,4,7,1,1,3,8,23,2,2,7,8, +6,4,1,1,5,10,205,3,2,10,2,1,1,5,5,77,3,2,5,2,17,2,16,33,25,1,0,28,1,2,2,4,14, +22,5,1,1,3,6,1,1,2,7,5,4,9,5,4,5,6,5,7,6,2,9,4,17,2,16,35,25,1,0,30,1,1,2,4, +1,1,4,5,1,1,5,6,3,4,2,2,5,6,7,51,4,7,4,1,1,3,9,2,9,2,17,2,16,38,25,1,0,33,1, +1,5,4,1,1,4,5,1,1,3,6,1,1,2,7,23,2,3,4,5,6,7,4,1,1,6,9,77,3,2,9,2,17,2,16,129, +32,25,4,0,155,14,1,7,8,3,7,115,0,14,2,8,8,3,8,77,0,14,22,9,8,3,9,30,0,1,2,3, +10,1,1,5,11,4,7,2,4,6,5,4,3,11,12,1,2,5,4,5,3,5,12,3,2,10,3,23,2,2,4,5,6,10, +1,1,2,11,51,10,11,12,1,1,4,13,1,1,3,14,23,2,2,13,14,12,4,1,1,5,16,205,3,2,16, +2,1,1,5,9,141,3,1,1,4,11,1,1,2,12,1,1,3,13,3,6,2,2,4,11,12,13,4,2,9,2,1,1,2, +8,51,4,8,9,1,1,4,10,1,1,3,11,23,2,2,10,11,9,4,1,1,5,13,205,3,2,13,2,17,2,16, +98,25,3,0,93,32,4,3,6,7,8,80,7,52,0,32,7,2,9,10,15,9,11,14,2,12,8,11,12,22,0, +1,1,4,13,6,6,5,8,10,6,3,3,1,1,6,5,9,9,4,2,13,3,7,6,3,8,10,6,3,3,9,9,4,2,5,3, +80,8,12,0,77,9,23,2,2,6,8,9,4,2,5,3,141,9,7,3,2,6,4,5,3,7,9,3,2,7,2,17,2,16, +114,25,2,0,109,208,3,65,0,141,5,8,3,5,21,0,1,2,2,6,1,1,7,7,3,3,2,3,7,3,1,2,4, +4,2,6,2,1,1,2,6,23,2,1,6,4,7,1,1,3,8,51,7,8,6,1,1,6,4,1,1,7,3,1,1,5,5,1,1,4, +7,2,4,5,1,1,2,5,23,2,1,5,4,6,1,1,3,7,51,6,7,8,1,1,6,4,1,1,7,3,1,1,5,5,1,1,4, +7,9,8,6,2,4,5,17,2,16,98,25,5,0,93,80,5,65,0,32,5,2,8,9,32,8,2,10,11,15,11,12, +14,2,13,8,12,13,24,0,1,1,5,14,6,8,6,4,7,6,9,10,3,3,1,1,7,5,9,11,4,2,14,3,1,1, +3,14,6,8,4,10,6,7,9,4,3,3,9,11,4,2,14,2,80,6,10,0,77,8,5,6,5,8,6,2,4,5,1,1,2, +8,9,7,4,2,8,2,17,2,16,36,25,3,0,31,16,4,25,0,14,1,6,40,4,6,7,8,1,1,2,9,7,5,3, +7,3,5,3,14,0,4,2,9,2,24,4,17,2,16,3,0,3,255,2,16,3,0,3,254,2,16,3,0,3,253,2, +16,3,0,3,252,2,16,3,0,3,251,2,16,3,0,3,250,2,16,3,0,3,249,2,16,3,0,3,248,2,16, +3,0,3,247,2,16,3,0,3,246,2,16,3,0,3,245,2,16,3,0,3,244,2,16,3,0,3,243,2,16,3, +0,3,242,2,16,3,0,3,241,2,16,3,0,3,240,2,16,3,0,3,239,2,16,3,0,3,238,2,16,3,0, +3,237,2,16,3,0,3,236,2,16,3,0,3,235,2,16,3,0,3,234,2,16,3,0,3,233,2,16,3,0,3, +232,2,16,3,0,3,231,2,16,3,0,3,230,2,16,3,0,3,229,2,16,3,0,3,228,2,16,3,0,3,227, +2,16,3,0,3,226,2,16,3,0,3,225,2,16,3,0,3,224,2,16,3,0,3,223,2,16,3,0,3,222,2, +16,3,0,3,221,2,16,3,0,3,220,2,16,3,0,3,219,2,16,3,0,3,218,2,16,3,0,3,217,2,16, +3,0,3,216,2,16,3,0,3,215,2,16,3,0,3,214,2,16,3,0,3,213,2,16,3,0,3,212,2,16,3, +0,3,211,2,16,3,0,3,210,2,16,3,0,3,209,2,16,3,0,3,208,2,16,3,0,3,207,2,16,3,0, +3,206,2,16,3,0,3,205,2,16,3,0,3,204,2,16,3,0,3,203,2,16,3,0,3,202,2,16,3,0,3, +201,2,16,3,0,3,200,2,16,3,0,3,199,2,16,3,0,3,198,2,16,3,0,3,197,2,16,3,0,3,196, +2,16,3,0,3,195,2,16,3,0,3,194,2,16,3,0,3,193,2,16,3,0,3,192,2,16,3,0,3,191,2, +16,3,0,3,190,2,16,3,0,3,189,2,16,3,0,3,188,2,16,3,0,3,187,2,16,3,0,3,186,2,16, +3,0,3,185,2,16,3,0,3,184,2,16,3,0,3,183,2,16,3,0,3,182,2,16,3,0,3,181,2,16,3, +0,3,180,2,16,3,0,3,179,2,16,3,0,3,178,2,16,3,0,3,177,2,16,3,0,3,176,2,16,3,0, +3,175,2,16,3,0,3,174,2,16,3,0,3,173,2,16,3,0,3,172,2,16,3,0,3,171,2,16,3,0,3, +170,2,16,3,0,3,169,2,16,3,0,3,168,2,16,3,0,3,167,2,16,3,0,3,166,2,16,44,25,3, +0,39,32,5,2,6,7,15,7,8,16,8,15,0,1,1,2,9,14,10,10,5,6,5,10,6,2,9,4,1,1,2,9,5, +6,5,7,6,2,9,4,17,2,16,25,25,3,0,20,16,4,14,0,1,1,2,6,6,5,3,4,5,3,3,2,6,1,24, +4,17,2,16,52,25,1,0,47,16,3,11,0,1,1,3,4,1,1,2,3,2,4,1,1,2,2,4,1,1,2,5,1,1,3, +6,1,1,4,7,3,5,2,3,5,6,7,3,5,4,7,5,4,2,7,2,17,2,16,3,0,3,165,2,16,3,0,3,164,2, +16,3,0,3,163,2,16,3,0,3,162,2,16,3,0,3,161,2,16,3,0,3,160,2,16,3,0,3,159,2,16, +3,0,3,158,2,16,3,0,3,157,2,16,3,0,3,156,2,16,3,0,3,155,2,3,3,116,97,103,1,4, +1,1,2,16,3,0,3,154,2,16,3,0,3,153,2,16,3,0,3,152,2,16,3,0,3,151,2,16,3,0,3,150, +2,16,3,0,3,149,2,16,3,0,3,148,2,16,3,0,3,147,2,16,3,0,3,146,2,16,3,0,3,145,2, +16,3,0,3,144,2,16,3,0,3,143,2,16,3,0,3,142,2,16,3,0,3,141,2,16,3,0,3,140,2,16, +3,0,3,139,2,16,3,0,3,138,2,16,3,0,3,137,2,16,3,0,3,136,2,16,3,0,3,135,2,16,3, +0,3,134,2,16,3,0,3,133,2,16,3,0,3,132,2,16,3,0,3,131,2,16,3,0,3,130,2,16,3,0, +3,129,2,16,3,0,3,128,2,16,3,0,3,127,2,16,3,0,3,126,2,16,3,0,3,125,2,16,3,0,3, +124,2,16,1,84,1,17,2,137,76,1,1,17,2,137,76,1,1,17,3,137,73,1,137,74,1,17,2, +137,53,1,1,17,2,137,39,137,40,1,17,2,137,44,1,1,17,2,136,113,0,13,3,1,17,2,137, +46,1,1,17,4,136,72,1,136,73,0,13,3,1,17,2,137,48,1,1,17,2,136,73,3,1,17,5,129, +21,4,1,0,13,3,2,2,3,9,66,97,100,32,109,97,116,104,58,2,3,12,66,97,100,32,110, +117,109,98,101,114,58,32,1,40,2,0,0,1,0,13,0,1,40,2,0,0,0,1,1,17,2,137,107,136, +76,1,17,3,136,76,14,5,1,17,2,137,109,136,76,1,17,2,137,58,136,76,1,17,5,129, +29,1,137,9,3,138,73,1,17,6,129,29,3,136,77,136,76,4,138,122,1,17,2,137,113,1, +1,17,4,129,29,20,10,138,48,1,17,7,129,29,0,0,135,255,255,127,9,136,78,10,7,138, +83,1,17,2,137,113,1,1,17,3,136,78,12,136,79,1,17,2,137,118,1,1,17,7,136,79,14, +1,136,81,136,81,136,81,136,81,1,17,2,137,68,1,1,17,2,129,33,129,34,1,17,2,137, +70,1,1,17,3,136,82,1,129,34,1,17,4,136,82,2,129,37,129,37,1,17,2,137,65,1,1, +17,3,136,83,1,129,36,1,17,3,136,83,17,1,1,17,2,136,83,23,1,17,4,129,38,136,83, +21,138,125,1,17,2,137,127,1,1,17,13,129,39,26,13,8,23,139,9,3,9,136,84,11,4, +136,84,136,84,1,17,13,129,39,27,9,14,24,139,17,4,136,85,10,5,12,136,85,136,85, +1,17,2,129,38,129,39,1,17,2,137,74,1,1,17,2,136,87,1,1,17,2,138,8,129,40,1,17, +2,137,50,2,1,17,3,136,89,3,129,49,1,17,11,86,9,4,129,50,31,139,20,3,2,1,7,137, +127,1,17,2,138,12,1,1,17,2,129,44,136,103,1,17,2,137,90,1,1,17,2,138,15,129, +45,1,17,2,137,57,1,1,17,3,136,96,2,136,98,1,17,4,136,96,14,138,6,0,0,135,255, +255,127,1,17,11,93,4,136,100,136,100,5,3,2,39,139,27,1,0,0,135,255,255,127,1, +17,2,138,20,1,1,17,2,136,98,129,50,1,17,2,138,22,1,1,17,4,129,50,43,139,25,1, +1,17,4,129,48,136,114,136,114,136,114,1,17,2,137,101,1,1,17,2,136,99,136,117, +1,17,2,136,99,136,117,1,17,7,129,50,129,51,25,24,2,136,118,1,1,17,2,137,105, +1,1,17,2,138,25,27,1,17,3,136,102,6,1,1,17,2,136,102,1,1,17,2,138,33,1,1,17, +2,102,55,1,17,2,138,32,1,1,17,3,136,102,1,136,103,1,17,3,136,102,136,106,1,1, +17,3,136,102,3,1,1,17,3,136,105,4,136,106,1,17,3,136,105,136,109,1,1,17,3,136, +105,6,1,1,17,4,136,105,136,111,4,1,1,17,2,136,111,1,1,17,2,137,21,15,1,17,3, +129,66,25,1,1,17,3,129,66,17,1,1,17,3,138,39,43,1,1,17,3,136,110,45,1,1,17,2, +136,110,1,1,17,3,136,110,47,1,1,17,3,136,110,48,1,1,17,2,136,110,1,1,17,3,136, +110,1,20,1,17,4,129,73,29,11,1,1,17,2,138,55,1,1,17,13,129,74,129,95,31,129, +95,76,139,0,129,95,137,9,137,9,1,137,9,137,9,137,9,1,17,2,138,57,1,1,17,2,138, +53,75,1,17,3,136,115,2,1,1,17,2,138,55,77,1,17,2,136,116,78,1,17,6,136,116,5, +3,2,1,79,1,17,2,138,3,129,80,1,17,2,136,110,1,1,17,5,129,4,85,139,1,86,1,1,17, +3,129,82,62,136,111,1,17,2,138,15,1,1,17,4,129,83,64,80,136,113,1,17,2,138,17, +1,1,17,3,136,114,3,0,0,131,255,255,127,1,17,3,136,114,2,4,1,17,7,129,17,0,0, +135,255,255,127,68,2,69,1,136,117,1,17,2,138,21,1,1,17,3,136,104,88,136,105, +1,17,3,136,104,71,1,1,17,2,138,76,1,1,17,3,136,105,73,138,60,1,17,4,136,105, +58,1,2,1,17,3,136,105,6,1,1,17,2,136,105,1,1,17,2,138,81,137,50,1,17,2,129,96, +1,1,17,2,138,80,1,1,17,3,136,102,80,136,103,1,17,4,129,29,136,105,65,1,1,17, +4,129,99,3,63,1,1,17,2,136,108,1,1,40,2,0,0,0,0,13,0,1,17,3,136,106,77,138,77, +1,17,3,129,102,78,1,1,17,5,129,102,68,1,4,3,1,17,3,136,108,69,1,1,17,2,138,93, +1,1,17,2,136,109,92,1,17,2,136,109,1,1,17,2,136,109,1,1,17,2,136,111,3,1,17, +2,136,111,1,1,17,5,136,111,97,3,1,6,1,17,2,138,100,1,1,17,2,138,96,21,1,17,2, +136,110,100,1,17,2,136,111,101,1,17,2,136,118,102,1,17,3,137,0,25,1,1,17,2,136, +120,104,1,17,3,136,114,27,1,1,17,3,136,118,106,1,1,17,14,129,116,129,1,139,89, +107,44,136,118,136,118,29,8,7,6,4,1,139,85,1,17,3,129,115,1,138,98,1,17,2,138, +111,1,1,17,2,129,116,0,0,132,128,128,0,1,24,2,0,0,2,0,0,1,1,24,2,0,0,8,0,0,3, +1,24,2,0,0,32,0,0,5,1,24,4,0,0,4,0,0,2,3,2,1,24,2,0,0,129,0,0,0,7,1,24,2,0,0, +132,0,0,0,9,1,24,4,0,0,64,0,0,6,4,2,1,24,2,0,0,144,0,0,0,11,1,24,2,0,0,192,0, +0,0,13,1,24,4,0,0,136,0,0,0,10,4,2,1,24,4,0,0,16,0,0,4,7,4,1,24,2,0,0,130,128, +0,0,0,15,1,24,2,0,0,136,128,0,0,0,17,1,24,4,0,0,129,128,0,0,0,14,5,2,1,24,2, +0,0,160,128,0,0,0,19,1,24,2,0,0,129,128,128,0,0,0,21,1,24,2,0,0,132,128,128, +0,0,0,23,1,24,4,0,0,144,128,0,0,0,18,5,3,1,24,4,0,0,130,128,128,0,0,0,22,3,2, +1,24,4,0,0,160,0,0,0,12,10,6,1,24,4,0,0,192,128,0,0,0,20,3,2,1,26,4,0,0,132, +128,0,0,0,16,2,1,1,24,4,0,0,130,0,0,0,8,12,1,1,17,3,137,8,129,5,137,53,1,17, +3,138,124,25,1,1,17,4,130,13,26,1,138,102,1,17,3,137,9,129,9,137,10,1,17,3,137, +9,129,26,1,1,17,3,137,9,129,9,1,1,17,3,139,6,129,2,1,1,17,4,137,10,129,45,1, +8,1,17,3,139,7,129,4,1,1,17,6,130,19,33,138,24,129,47,1,10,1,17,4,130,19,123, +8,1,1,17,4,130,19,127,124,1,1,17,2,138,96,1,1,17,2,129,87,1,1,17,8,129,87,129, +20,137,16,137,16,139,10,139,10,39,1,1,17,2,139,23,1,1,17,3,137,16,129,22,139, +12,1,17,3,137,17,129,23,139,13,1,17,3,137,17,54,137,19,1,17,3,137,17,55,1,1, +17,3,137,17,129,43,1,1,17,3,137,17,6,1,1,17,6,130,98,129,28,6,5,130,29,1,1,17, +2,139,31,1,1,17,2,137,19,137,114,1,17,2,137,20,137,115,1,17,2,137,21,137,116, +1,17,2,137,22,137,117,1,17,2,138,77,5,1,17,2,139,32,6,1,17,3,137,23,109,1,1, +17,2,138,26,1,1,17,3,137,24,111,1,1,17,2,137,23,137,24,1,17,2,138,105,130,40, +1,17,28,130,40,129,66,129,53,129,48,114,11,137,29,129,63,140,57,129,51,129,49, +129,44,10,137,29,129,43,137,124,9,137,29,137,124,137,124,8,137,29,7,3,137,29, +2,1,137,29,1,17,2,139,44,1,1,17,3,137,49,129,43,137,25,1,17,3,137,50,129,44, +137,26,1,17,3,137,51,129,45,137,27,1,17,3,137,52,129,46,137,28,1,17,2,138,90, +18,1,17,2,139,45,19,1,17,3,137,36,122,1,1,17,3,139,45,129,48,1,1,17,3,137,32, +124,1,1,17,3,137,58,129,52,137,34,1,17,3,137,83,129,51,137,38,1,17,2,138,119, +130,54,1,17,29,130,53,129,80,129,62,129,67,129,0,137,38,12,129,77,140,70,129, +57,138,10,129,63,137,38,11,129,58,129,65,137,38,10,138,10,138,10,137,38,9,129, +53,8,4,3,2,1,137,43,1,17,2,139,58,1,1,17,3,137,1,15,129,91,1,17,2,139,55,2,1, +17,3,139,55,17,1,1,17,5,137,3,4,129,94,1,18,1,17,2,137,0,137,1,1,17,2,139,12, +1,1,17,2,137,1,1,1,18,2,1,129,4,2,3,29,115,116,114,105,110,103,45,108,101,110, +103,116,104,58,32,110,111,116,32,97,32,115,116,114,105,110,103,58,32,2,3,24, +115,116,114,45,105,116,101,114,58,32,110,111,116,32,97,32,115,116,114,105,110, +103,58,32,1,17,3,136,43,129,103,2,1,17,2,136,42,136,43,1,17,2,139,11,1,1,17, +2,136,42,136,43,1,17,2,139,21,1,1,17,2,130,52,3,1,17,3,136,85,16,139,58,1,17, +2,136,45,1,1,17,7,136,45,8,3,4,1,129,111,9,1,17,2,139,78,1,1,17,2,139,1,1,2, +3,36,66,97,100,32,118,101,99,116,111,114,32,110,111,100,101,32,105,110,32,100, +105,115,112,97,116,99,104,45,49,58,32,116,121,112,101,32,2,3,27,76,101,97,102, +32,118,101,99,116,111,114,32,105,110,32,100,105,115,112,97,116,99,104,45,50, +58,32,2,3,35,66,97,100,32,118,101,99,116,111,114,32,110,111,100,101,32,105,110, +32,100,105,115,112,97,116,99,104,45,50,58,32,111,98,106,32,2,3,24,118,101,99, +45,108,101,97,102,45,111,102,58,32,98,97,100,32,105,110,100,101,120,58,32,2, +3,23,118,101,99,45,108,101,110,58,32,110,111,116,32,97,32,118,101,99,116,111, +114,58,32,1,17,4,135,126,0,0,159,127,129,119,5,1,17,4,130,22,129,120,5,4,1,17, +2,139,0,2,1,17,2,139,1,3,1,17,6,136,1,3,2,4,0,0,160,0,1,1,17,2,139,90,1,1,17, +2,138,18,5,1,17,3,136,1,2,1,1,17,6,130,66,7,0,0,160,0,1,129,127,10,1,17,5,136, +1,130,0,10,139,104,140,101,1,17,2,139,43,130,63,1,17,2,137,5,1,1,17,3,130,64, +35,1,1,17,2,139,98,1,1,17,3,135,102,33,135,103,1,17,4,135,102,41,1,0,0,160,0, +1,17,3,135,102,3,1,1,17,3,135,102,9,1,1,17,4,135,102,9,137,5,1,2,3,17,104,111, +119,32,100,111,32,105,32,105,116,101,114,97,116,101,32,1,17,2,133,90,136,88, +1,17,3,133,90,139,62,1,1,17,2,133,88,133,89,1,17,4,133,88,1,130,6,133,86,1,17, +3,133,88,139,65,1,1,17,2,139,113,1,1,17,2,133,85,133,86,1,17,2,133,85,139,11, +1,17,3,133,85,1,139,61,1,17,2,133,85,1,1,17,3,133,85,53,137,75,1,17,2,130,70, +1,1,17,2,133,86,1,1,1,2,0,0,0,0,13,0,1,1,2,1,0,13,0,1,17,3,133,78,1,133,80,1, +17,4,133,76,139,109,1,133,77,1,17,4,133,76,2,139,78,1,1,17,2,139,123,1,1,17, +4,133,77,130,30,20,21,1,17,4,133,77,136,3,1,46,1,17,3,133,77,136,101,1,1,17, +3,139,24,139,83,1,1,17,2,139,123,5,1,17,3,133,79,2,1,1,17,2,139,125,10,1,17, +3,133,81,4,1,1,17,2,140,8,140,9,2,16,3,0,3,123,2,16,3,0,3,122,2,16,3,0,3,121, +2,16,11,25,3,0,6,50,4,5,6,24,6,17,2,16,10,25,2,0,5,62,4,5,24,5,17,2,16,3,0,3, +120,1,17,3,131,59,2,140,7,1,17,2,140,9,1,2,16,1,84,1,17,2,140,0,4,1,17,2,140, +0,2,1,17,2,140,0,1,1,17,3,139,125,1,139,126,1,17,2,139,125,1,1,17,3,139,125, +2,140,73,1,17,2,139,107,3,1,17,2,139,126,4,1,17,2,139,126,5,1,17,2,139,126,6, +1,17,2,139,126,6,1,17,3,139,126,8,1,1,17,2,139,126,9,1,17,2,139,126,10,1,17, +5,139,123,2,139,125,7,139,124,1,17,2,139,123,1,1,17,4,139,123,4,140,0,1,1,17, +4,139,120,1,139,122,139,121,1,17,3,139,120,10,1,1,17,3,139,110,139,117,139,111, +1,17,2,140,31,1,1,17,2,139,109,139,110,1,17,2,139,112,1,1,17,2,139,109,139,110, +1,17,2,139,114,1,1,17,2,139,110,140,38,1,17,2,139,110,1,1,17,2,139,110,1,1,17, +2,139,118,1,1,17,2,139,109,139,110,1,17,2,139,112,1,1,17,2,139,109,139,110,1, +17,2,139,122,1,1,17,2,139,110,140,46,1,17,2,139,110,1,1,17,2,140,49,1,1,17,2, +139,110,139,111,1,17,2,140,51,1,1,17,2,139,108,139,109,1,17,2,140,1,1,1,17,2, +140,52,140,53,1,17,2,139,110,1,1,17,2,139,110,1,1,17,2,139,112,3,1,17,3,139, +111,4,1,1,17,4,139,111,5,3,1,1,17,2,140,60,139,111,1,17,2,139,111,1,1,17,3,139, +109,1,139,110,1,17,4,139,109,2,139,112,1,1,17,2,139,109,1,1,17,2,139,108,139, +109,1,17,3,139,108,20,1,1,17,2,139,106,139,107,1,17,3,139,106,30,1,1,17,3,139, +106,53,1,1,17,2,139,105,139,106,1,17,2,140,19,1,1,17,4,139,105,11,140,77,139, +106,1,17,2,139,105,1,1,17,4,139,104,13,139,122,139,105,1,17,2,139,104,1,2,3, +17,102,117,112,100,58,32,110,111,116,32,116,104,101,114,101,58,32,2,3,3,102, +111,111,1,17,2,139,102,0,13,3,1,17,2,139,100,139,101,1,17,2,139,100,139,103, +1,17,6,139,98,0,13,3,2,1,139,100,139,99,1,17,2,140,30,1,1,17,2,139,99,0,13,3, +1,17,2,140,32,1,1,17,7,139,98,0,13,3,65,9,139,100,139,99,139,100,1,17,2,140, +34,1,1,17,5,139,98,10,5,139,99,1,1,17,3,139,98,1,11,1,17,2,139,97,139,98,1,17, +2,139,96,139,97,1,17,3,139,96,139,98,1,1,17,5,139,96,140,98,3,0,13,3,1,1,17, +4,139,96,0,13,3,140,99,1,1,17,2,140,42,1,1,17,2,139,97,139,102,1,17,2,139,102, +139,103,1,17,3,139,98,139,106,1,1,17,5,139,98,140,104,3,0,13,3,1,1,17,4,139, +98,140,105,1,0,13,3,1,17,4,139,98,140,106,1,0,13,3,1,17,2,140,49,1,1,17,2,139, +99,14,1,17,4,139,99,65,1,0,13,3,1,17,3,139,98,10,139,99,1,17,3,139,98,139,127, +139,124,1,17,3,139,97,140,1,139,98,1,17,2,139,95,2,1,17,2,139,95,1,1,17,3,139, +95,139,99,1,1,17,2,139,94,139,95,1,17,3,139,97,139,101,1,1,17,7,139,95,0,13, +3,139,101,3,140,2,140,3,1,1,17,2,140,113,1,1,17,2,139,96,8,1,17,2,139,96,10, +1,17,4,139,96,3,2,1,1,17,4,139,96,140,123,1,0,13,3,1,17,2,140,118,1,1,17,3,139, +97,1,140,3,1,17,3,139,114,26,139,95,2,3,9,66,97,100,32,109,97,116,104,58,2,3, +12,66,97,100,32,110,117,109,98,101,114,58,32,2,3,17,100,105,118,105,115,105, +111,110,32,98,121,32,122,101,114,111,32,2,3,10,98,97,100,32,109,97,116,104,58, +32,2,3,17,78,111,32,97,114,103,117,109,101,110,116,115,32,102,111,114,32,1,40, +2,0,0,1,0,13,0,1,40,2,0,0,0,1,1,17,2,141,0,139,97,1,17,3,139,97,109,8,1,17,2, +141,2,139,97,1,17,2,140,79,139,97,1,17,5,132,50,1,140,30,3,141,94,1,17,6,132, +50,3,139,98,139,97,4,142,15,1,17,2,141,6,1,1,17,4,132,50,115,13,141,69,1,17, +7,132,50,0,0,135,255,255,127,9,139,99,10,7,141,104,1,17,2,141,6,1,1,17,3,139, +99,12,139,100,1,17,2,141,11,1,1,17,7,139,100,14,1,139,102,139,102,139,102,139, +102,1,17,2,140,89,1,1,17,2,132,54,132,55,1,17,2,140,91,1,1,17,3,139,103,1,132, +55,1,17,4,139,103,2,132,58,132,58,1,17,2,140,86,1,1,17,3,139,104,1,132,57,1, +17,3,139,104,17,1,1,17,2,139,104,23,1,17,4,132,59,139,104,21,142,18,1,17,2,141, +20,1,1,17,13,132,60,26,13,8,23,142,30,3,9,139,105,11,4,139,105,139,105,1,17, +13,132,60,27,9,14,24,142,38,4,139,106,10,5,12,139,106,139,106,1,17,2,132,59, +132,60,1,17,2,140,95,1,1,17,2,139,108,1,1,17,2,141,29,132,61,1,17,2,140,71,2, +1,17,3,139,110,3,132,70,1,17,11,131,107,9,4,132,71,31,142,41,3,2,1,7,141,20, +1,17,2,141,33,1,1,17,2,132,65,139,124,1,17,2,140,111,1,1,17,2,141,36,132,66, +1,17,2,140,78,1,1,17,3,139,117,2,139,119,1,17,4,139,117,14,141,27,0,0,135,255, +255,127,1,17,11,131,114,4,139,121,139,121,5,3,2,39,142,48,1,0,0,135,255,255, +127,1,17,2,141,41,1,1,17,2,139,119,132,71,1,17,2,141,43,1,1,17,2,139,120,140, +6,1,17,2,141,45,1,1,17,2,139,121,132,74,1,17,2,141,47,1,1,17,3,140,26,1,139, +122,1,17,4,132,76,48,142,51,6,1,17,4,132,76,49,142,50,5,1,17,4,132,76,50,142, +49,3,1,17,4,132,76,140,14,140,14,140,14,1,17,2,141,1,1,1,17,2,139,127,140,17, +1,17,2,139,127,140,17,1,17,7,132,78,132,79,32,31,2,140,18,1,1,17,2,141,5,1,1, +17,2,141,53,34,1,17,3,140,2,6,1,1,17,2,140,2,1,1,17,2,141,61,1,1,17,2,132,2, +62,1,17,2,141,60,1,1,17,3,140,2,1,140,3,1,17,3,140,2,140,6,1,1,17,3,140,2,3, +1,1,17,3,140,5,4,140,6,1,17,3,140,5,140,9,1,1,17,3,140,5,6,1,1,17,4,140,5,140, +11,4,1,1,17,2,140,11,1,1,17,2,140,49,15,1,17,3,132,94,32,1,1,17,3,132,94,17, +1,1,17,3,141,67,50,1,1,17,3,140,10,52,1,1,17,2,140,10,1,1,17,3,140,10,54,1,1, +17,3,140,10,55,1,1,17,2,140,10,1,1,17,3,140,10,1,20,1,17,4,132,101,29,11,1,1, +17,2,141,83,1,1,17,13,132,102,132,123,31,132,123,83,142,28,132,123,140,37,140, +37,1,140,37,140,37,140,37,1,17,2,141,85,1,1,17,2,141,81,82,1,17,3,140,15,2,1, +1,17,2,141,83,84,1,17,2,140,16,85,1,17,6,140,16,5,3,2,1,86,1,17,3,140,16,85, +140,118,1,17,3,140,16,2,1,1,17,2,140,16,3,1,17,2,140,17,2,1,17,3,140,16,5,140, +17,1,17,3,140,16,6,140,18,1,17,2,141,37,132,114,1,17,2,140,16,1,1,17,5,132,38, +98,142,35,99,1,1,17,3,132,116,75,140,17,1,17,2,141,49,1,1,17,4,132,117,77,93, +140,19,1,17,2,141,51,1,1,17,3,140,20,3,0,0,131,255,255,127,1,17,3,140,20,2,4, +1,17,7,132,51,0,0,135,255,255,127,81,2,82,1,140,23,1,17,2,141,55,1,1,17,3,140, +22,99,140,25,1,17,3,140,22,102,1,1,17,3,140,22,85,1,1,17,2,141,59,1,1,17,3,140, +23,88,141,100,1,17,3,140,23,72,1,1,17,3,141,106,89,1,1,17,4,140,24,74,1,4,1, +17,3,140,24,9,1,1,17,2,140,24,1,1,17,2,140,24,95,1,17,3,140,24,2,1,1,17,3,140, +22,113,140,23,1,17,3,140,22,96,1,1,17,2,141,122,1,1,17,3,140,23,98,141,106,1, +17,4,140,23,83,1,2,1,17,3,140,23,18,1,1,17,2,140,23,1,1,17,2,141,127,140,96, +1,17,2,133,14,1,1,17,2,141,126,1,1,17,3,140,20,105,140,21,1,17,4,132,75,140, +23,90,1,1,17,4,133,17,3,83,1,1,17,2,140,26,1,1,40,2,0,0,0,0,13,0,1,17,3,140, +24,102,141,123,1,17,3,133,20,103,1,1,17,5,133,20,88,1,4,3,1,17,3,140,26,89,1, +1,17,2,142,11,1,1,17,2,140,27,117,1,17,2,140,27,1,1,17,2,140,27,1,1,17,2,140, +29,3,1,17,2,140,29,1,1,17,5,140,29,122,3,1,6,1,17,2,142,18,1,1,17,2,141,60,1, +1,17,3,142,14,123,1,1,17,3,140,32,23,1,1,17,3,141,0,51,133,31,1,17,2,142,18, +32,1,17,2,141,65,33,1,17,2,142,20,4,1,17,3,140,36,129,3,1,1,17,13,133,35,129, +26,142,125,133,37,56,140,59,5,6,129,4,4,140,59,3,1,1,17,2,142,23,30,1,17,2,140, +37,129,6,1,17,2,140,38,129,7,1,17,2,140,45,129,8,1,17,3,140,55,34,1,1,17,2,140, +47,129,10,1,17,3,140,41,36,1,1,17,3,140,45,129,12,1,1,17,14,133,43,129,35,143, +16,129,13,65,140,45,140,45,38,8,7,6,4,1,143,12,1,17,3,140,42,129,14,141,85,1, +17,3,140,43,129,15,141,86,1,17,3,140,46,50,1,1,17,3,140,44,129,17,142,45,1,17, +3,140,45,129,18,142,46,1,17,3,140,45,129,19,1,1,17,3,140,45,129,20,142,48,1, +17,3,140,48,129,21,142,49,1,17,3,140,48,129,22,1,1,17,3,140,69,57,1,1,17,3,140, +49,129,24,142,52,1,17,3,140,55,59,1,1,17,3,140,59,129,26,1,1,17,16,133,56,129, +49,143,24,129,27,141,98,79,140,56,61,13,11,10,142,55,8,7,4,1,1,17,3,133,56,15, +142,39,1,17,2,142,52,1,1,17,2,133,57,0,0,132,128,128,0,1,24,2,0,0,2,0,0,1,1, +24,2,0,0,8,0,0,3,1,24,2,0,0,32,0,0,5,1,24,4,0,0,4,0,0,2,3,2,1,24,2,0,0,129,0, +0,0,7,1,24,2,0,0,132,0,0,0,9,1,24,4,0,0,64,0,0,6,4,2,1,24,2,0,0,144,0,0,0,11, +1,24,2,0,0,192,0,0,0,13,1,24,4,0,0,136,0,0,0,10,4,2,1,24,4,0,0,16,0,0,4,7,4, +1,24,2,0,0,130,128,0,0,0,15,1,24,2,0,0,136,128,0,0,0,17,1,24,4,0,0,129,128,0, +0,0,14,5,2,1,24,2,0,0,160,128,0,0,0,19,1,24,2,0,0,129,128,128,0,0,0,21,1,24, +2,0,0,132,128,128,0,0,0,23,1,24,4,0,0,144,128,0,0,0,18,5,3,1,24,4,0,0,130,128, +128,0,0,0,22,3,2,1,24,4,0,0,160,0,0,0,12,10,6,1,24,4,0,0,192,128,0,0,0,20,3, +2,1,26,4,0,0,132,128,0,0,0,16,2,1,1,24,4,0,0,130,0,0,0,8,12,1,1,17,3,140,77, +129,53,140,122,1,17,3,142,65,25,1,1,17,4,133,82,26,1,142,43,1,17,3,140,78,129, +57,140,79,1,17,3,140,78,129,74,1,1,17,3,140,78,129,57,1,1,17,3,142,75,129,50, +1,1,17,4,140,79,130,0,1,8,1,17,3,142,76,129,52,1,1,17,6,133,88,33,141,93,130, +2,1,10,1,17,4,133,88,129,38,8,1,1,17,4,133,88,129,47,129,39,1,1,17,2,142,37, +1,1,17,2,133,28,1,1,17,8,133,28,129,68,140,85,140,85,142,79,142,79,39,1,1,17, +2,142,92,1,1,17,3,140,85,129,70,142,81,1,17,3,140,86,129,71,142,82,1,17,3,140, +86,77,140,88,1,17,3,140,86,78,1,1,17,3,140,86,129,91,1,1,17,3,140,86,6,1,1,17, +6,134,39,129,76,6,5,133,98,1,1,17,2,142,100,1,1,17,2,140,88,141,55,1,17,2,140, +89,141,56,1,17,2,140,90,141,57,1,17,2,140,91,141,58,1,17,2,142,18,5,1,17,2,142, +101,6,1,17,3,140,92,129,22,1,1,17,2,141,95,1,1,17,3,140,93,129,24,1,1,17,2,140, +92,140,93,1,17,2,142,46,133,109,1,17,28,133,109,129,114,129,101,129,96,129,27, +11,140,98,129,111,143,126,129,99,129,97,129,92,10,140,98,129,91,141,65,9,140, +98,141,65,141,65,8,140,98,7,3,140,98,2,1,140,98,1,17,2,142,113,1,1,17,3,140, +118,129,91,140,94,1,17,3,140,119,129,92,140,95,1,17,3,140,120,129,93,140,96, +1,17,3,140,121,129,94,140,97,1,17,2,142,31,18,1,17,2,142,114,19,1,17,3,140,105, +129,35,1,1,17,3,142,114,129,96,1,1,17,3,140,101,129,37,1,1,17,3,140,127,129, +100,140,103,1,17,3,141,24,129,99,140,107,1,17,2,142,60,133,123,1,17,29,133,122, +130,0,129,110,129,115,129,41,140,107,12,129,125,144,11,129,105,141,79,129,111, +140,107,11,129,106,129,113,140,107,10,141,79,141,79,140,107,9,129,101,8,4,3, +2,1,140,112,1,17,2,142,127,1,1,17,2,140,106,28,1,17,2,142,64,133,127,1,17,2, +140,108,30,1,17,2,142,66,134,1,1,17,2,140,110,32,1,17,2,142,68,134,3,1,17,2, +140,112,34,1,17,2,142,70,134,5,1,17,2,143,3,36,1,17,2,141,33,1,1,17,2,142,73, +134,8,1,17,2,140,117,39,1,17,3,141,40,27,134,10,1,17,2,140,118,1,1,17,2,140, +118,1,1,17,3,143,5,16,1,1,17,2,140,119,1,1,17,2,142,80,134,15,1,17,27,134,13, +129,93,134,57,134,57,18,17,130,17,143,90,134,57,141,99,16,15,129,63,141,99,141, +99,14,13,141,99,141,99,12,11,9,8,7,2,1,144,30,1,17,2,143,19,1,1,17,2,141,7,134, +18,1,17,3,143,13,22,1,1,17,3,140,124,3,1,1,17,3,140,124,4,1,1,17,2,140,124,1, +1,17,3,143,14,40,1,1,17,3,140,125,7,1,1,17,3,140,125,8,1,1,17,3,143,18,43,1, +1,17,3,140,126,10,1,1,17,2,141,17,134,28,1,17,3,140,127,12,1,1,17,2,140,127, +1,1,17,3,140,127,14,1,1,17,2,141,21,134,32,1,17,3,141,0,36,1,1,17,3,141,4,17, +1,1,17,2,141,4,1,1,17,3,141,2,19,1,1,17,3,143,30,54,1,1,17,3,141,3,21,1,1,17, +2,143,36,69,1,17,3,141,4,23,1,1,17,2,143,38,71,1,17,2,141,99,72,1,17,12,134, +39,131,25,130,50,144,56,26,16,12,5,3,2,1,73,1,17,2,143,46,1,1,17,2,141,8,48, +1,17,6,134,41,130,41,1,131,28,130,52,143,124,1,17,3,141,96,131,11,30,1,17,2, +143,45,65,1,17,2,141,8,1,1,17,3,141,8,129,90,1,1,17,3,141,7,131,15,141,8,1,17, +3,141,56,2,142,102,1,17,3,141,8,129,5,1,1,17,5,141,8,131,14,3,1,142,26,1,17, +2,141,6,141,7,1,17,4,141,6,2,6,141,59,1,17,2,141,5,141,6,1,17,5,141,5,129,98, +2,61,1,1,17,7,141,5,141,12,0,32,1,129,99,4,142,68,1,1,17,2,143,10,1,1,17,3,141, +5,78,131,25,1,17,2,143,59,65,1,17,3,143,59,80,1,1,17,5,141,7,67,131,28,1,81, +1,17,2,143,62,48,1,17,3,143,62,49,1,1,17,4,141,9,50,131,31,1,1,17,2,143,65,24, +1,17,4,141,10,25,22,1,1,17,2,141,9,141,10,1,17,2,143,21,1,1,17,2,141,10,1,1, +18,2,1,130,69,1,18,2,2,129,114,1,18,2,3,129,112,1,18,2,4,129,114,1,18,2,5,129, +113,1,17,5,141,14,131,42,131,60,142,107,130,83,1,18,3,1,129,114,0,13,1,1,18, +3,2,129,114,0,13,1,2,3,17,108,114,101,102,58,32,111,117,116,32,111,102,32,108, +105,115,116,2,3,30,108,105,115,116,45,115,101,116,58,32,111,117,116,32,111,102, +32,108,105,115,116,32,115,101,116,116,105,110,103,32,2,3,28,108,105,115,116, +45,100,101,108,58,32,111,117,116,32,111,102,32,108,105,115,116,44,32,108,101, +102,116,32,2,3,29,108,101,100,110,58,32,111,117,116,32,111,102,32,108,105,115, +116,44,32,114,101,109,97,105,110,105,110,103,32,2,3,24,108,105,110,115,58,32, +111,117,116,32,111,102,32,108,105,115,116,44,32,108,101,102,116,32,2,3,10,98, +97,100,32,105,111,116,97,58,32,1,17,5,134,81,131,69,6,23,143,77,1,17,2,143,90, +1,1,17,2,141,23,143,90,1,17,5,134,83,131,72,8,26,1,1,17,2,143,41,1,1,17,2,141, +76,143,93,1,17,5,134,85,131,75,10,29,1,1,17,2,143,96,1,1,17,2,141,29,143,96, +1,17,5,134,87,131,78,12,32,1,1,17,2,143,47,1,1,17,2,141,32,143,99,1,17,5,134, +89,131,81,14,35,1,1,17,2,143,50,1,1,17,2,141,34,40,1,17,3,141,34,131,66,1,1, +17,2,141,87,143,104,1,17,3,134,93,40,1,1,17,2,143,107,1,1,17,3,134,94,42,143, +96,1,17,2,143,109,1,1,17,2,141,39,143,109,1,17,3,141,39,48,1,1,17,3,141,39,36, +1,1,17,2,143,61,1,1,17,2,141,43,143,113,1,17,3,141,43,52,1,1,17,3,141,43,39, +1,1,17,2,143,65,1,1,17,4,141,44,131,98,30,145,6,1,17,2,141,44,2,1,17,5,141,44, +45,2,43,1,1,17,2,141,46,8,1,17,4,141,45,46,2,1,1,17,3,141,45,46,1,1,17,6,134, +109,131,63,143,44,143,44,58,142,41,1,17,2,141,46,1,1,17,2,141,46,143,125,1,17, +2,141,46,1,1,17,2,143,76,1,1,17,3,141,47,144,0,144,0,1,17,2,141,47,1,1,17,2, +143,79,1,1,17,2,143,67,144,3,1,17,3,141,49,2,1,1,17,2,144,6,1,1,17,4,141,49, +144,6,7,141,50,1,17,2,143,76,1,1,17,3,141,50,3,143,125,1,17,2,144,10,1,1,17, +2,141,51,1,1,17,3,141,51,4,1,1,17,2,141,51,1,1,17,3,141,50,130,109,143,21,1, +17,3,141,50,74,142,60,1,17,3,141,50,130,111,1,1,17,4,135,1,76,3,1,1,17,3,135, +1,130,97,1,1,17,2,143,95,1,1,17,2,141,53,1,1,17,2,141,54,2,1,17,2,141,54,79, +1,17,2,142,45,1,1,17,2,141,56,81,1,17,2,142,47,1,1,17,10,135,8,85,129,27,6,5, +131,3,3,1,131,25,145,4,1,17,2,144,27,1,1,17,2,141,47,142,22,1,17,3,141,47,143, +113,1,1,17,2,144,30,1,1,17,3,141,48,142,76,143,104,1,17,3,141,48,143,116,1,1, +17,2,143,109,1,1,17,3,141,49,142,79,143,107,1,17,3,141,51,143,119,1,1,17,2,143, +112,1,1,17,2,141,51,142,31,1,17,3,141,51,1,144,37,1,17,3,141,51,143,123,1,1, +17,2,144,40,1,1,17,3,141,47,144,24,144,40,1,17,3,141,47,143,126,1,1,17,2,144, +40,1,2,3,33,117,116,102,56,32,101,110,99,111,100,101,58,32,99,111,100,101,32, +112,111,105,110,116,32,116,111,111,32,104,105,103,104,32,1,17,3,135,26,95,0, +0,128,255,255,127,1,17,2,141,50,0,0,129,0,1,17,3,144,29,130,126,1,1,17,3,142, +114,1,141,51,1,17,3,141,51,2,1,1,17,3,141,51,131,17,1,1,17,3,141,51,4,1,1,17, +3,141,51,131,19,1,1,17,4,141,51,131,3,1,0,0,129,112,1,17,3,141,51,131,5,1,1, +17,5,141,51,132,35,11,131,22,1,1,17,3,141,50,9,141,51,1,17,3,141,57,10,1,1,17, +3,141,51,131,25,1,1,17,4,141,57,131,9,1,0,0,129,96,1,17,3,141,52,131,11,1,1, +17,6,141,52,113,6,0,0,129,128,128,0,131,28,1,1,17,3,141,51,15,141,52,1,17,4, +141,61,131,13,1,0,0,129,64,1,17,3,141,52,131,15,1,1,17,6,141,52,117,4,0,0,132, +128,0,131,32,1,1,17,4,141,52,118,1,0,0,144,0,1,17,4,141,52,119,1,0,0,129,0,1, +17,3,141,91,131,18,141,111,1,17,3,141,51,131,20,1,1,17,3,141,51,131,29,1,1,17, +6,141,51,141,54,0,0,129,0,129,5,1,0,0,129,64,1,17,5,135,52,124,141,56,144,28, +1,1,17,2,144,13,1,1,17,9,135,53,0,0,129,64,1,0,0,129,0,0,0,129,96,0,0,144,0, +0,0,129,112,0,0,132,128,0,0,0,129,120,1,17,4,141,53,144,39,1,141,54,1,17,4,141, +53,132,15,144,32,1,1,17,2,144,25,1,1,17,2,141,54,1,2,3,29,115,116,114,105,110, +103,45,108,101,110,103,116,104,58,32,110,111,116,32,97,32,115,116,114,105,110, +103,58,32,2,3,24,115,116,114,45,105,116,101,114,58,32,110,111,116,32,97,32,115, +116,114,105,110,103,58,32,2,3,25,115,116,114,45,105,116,101,114,114,58,32,110, +111,116,32,97,32,115,116,114,105,110,103,58,32,2,3,23,70,97,105,108,101,100, +32,116,111,32,109,97,107,101,32,115,116,114,105,110,103,58,32,1,1,2,0,0,0,0, +13,0,1,1,2,0,0,0,0,13,0,1,17,3,141,59,132,65,6,1,17,2,141,58,141,59,1,17,2,144, +27,1,1,17,2,141,58,141,59,1,17,2,144,37,1,1,17,2,135,68,3,1,17,3,141,101,129, +28,144,74,1,17,2,141,61,1,1,17,7,141,61,8,3,4,1,132,73,13,1,17,2,144,94,1,1, +17,2,144,17,1,1,17,2,135,73,141,63,1,17,2,144,45,1,1,17,2,141,64,141,65,1,17, +2,144,47,1,1,17,2,143,77,3,1,17,3,135,77,129,35,1,1,17,3,141,112,129,36,144, +85,1,17,2,141,68,1,1,17,7,141,68,19,3,5,1,132,84,23,1,17,2,144,105,1,1,17,2, +144,28,1,1,17,2,143,84,71,1,17,3,141,71,2,1,1,17,2,141,71,42,1,17,3,143,104, +2,43,1,17,3,144,41,3,44,1,17,3,143,106,4,135,23,1,17,3,144,43,5,4,1,17,5,135, +89,132,53,144,34,129,48,143,31,1,17,2,144,63,1,1,17,4,141,76,132,78,141,77,129, +53,1,17,4,141,76,132,68,1,32,1,17,4,141,75,132,80,141,76,129,55,1,17,4,141,75, +132,70,1,34,1,17,4,141,75,132,71,1,144,117,1,17,3,141,75,6,1,1,17,3,141,75,7, +1,1,17,3,141,75,8,1,1,17,5,141,75,129,61,7,130,97,1,1,17,3,141,75,129,48,1,1, +17,3,141,75,129,22,1,1,17,2,144,124,1,1,17,3,141,75,132,108,46,1,17,4,141,75, +132,68,141,77,1,1,17,2,143,16,3,1,17,3,141,76,132,70,1,1,17,3,141,74,129,55, +0,0,130,0,1,17,4,141,73,129,57,0,0,129,0,141,74,1,17,3,141,73,129,71,1,1,17, +5,141,73,90,1,6,141,79,1,17,6,141,73,141,79,129,60,4,0,0,129,0,1,1,17,7,141, +73,8,6,0,0,160,0,141,81,144,93,1,1,17,2,143,31,1,1,17,2,141,74,1,1,18,3,133, +8,62,1,1,17,2,143,27,1,1,17,3,143,21,31,1,1,17,3,141,77,32,1,1,17,2,141,77,145, +4,1,17,3,141,76,129,70,141,77,1,17,3,141,76,144,102,1,1,17,4,141,76,1,129,72, +141,79,1,17,5,141,76,144,104,4,143,14,1,1,17,3,141,76,144,105,1,1,17,2,145,22, +1,1,17,2,145,18,1,1,17,3,143,34,57,1,1,17,3,141,79,58,1,1,17,3,142,113,129,79, +1,1,17,3,141,80,70,1,1,17,3,142,99,71,1,1,17,4,141,79,129,79,141,80,0,0,131, +255,127,1,17,3,141,79,129,54,1,1,17,8,141,79,51,141,83,135,70,76,1,92,75,2,3, +36,66,97,100,32,118,101,99,116,111,114,32,110,111,100,101,32,105,110,32,100, +105,115,112,97,116,99,104,45,49,58,32,116,121,112,101,32,2,3,27,76,101,97,102, +32,118,101,99,116,111,114,32,105,110,32,100,105,115,112,97,116,99,104,45,50, +58,32,2,3,35,66,97,100,32,118,101,99,116,111,114,32,110,111,100,101,32,105,110, +32,100,105,115,112,97,116,99,104,45,50,58,32,111,98,106,32,2,3,39,98,97,100, +32,118,101,99,116,111,114,32,110,111,100,101,32,105,110,32,118,101,99,45,114, +101,102,45,100,105,103,105,116,58,32,116,121,112,101,32,2,3,20,118,101,99,45, +114,101,102,58,32,98,97,100,32,105,110,100,101,120,58,32,2,3,24,118,101,99,45, +108,101,97,102,45,111,102,58,32,98,97,100,32,105,110,100,101,120,58,32,2,3,23, +118,101,99,45,108,101,110,58,32,110,111,116,32,97,32,118,101,99,116,111,114, +58,32,2,3,34,111,117,116,32,111,102,32,108,101,97,118,101,115,32,98,101,102, +111,114,101,32,111,117,116,32,111,102,32,100,97,116,97,58,32,1,17,4,141,81,0, +0,159,127,133,20,8,1,17,4,135,105,133,21,8,7,1,17,2,144,83,2,1,17,2,144,84,3, +1,17,6,141,84,3,2,4,0,0,160,0,1,1,17,2,145,45,1,1,17,5,141,85,0,0,159,127,0, +0,160,0,133,26,11,1,17,2,145,47,1,1,17,2,143,103,1,1,17,3,141,87,8,1,1,17,3, +141,87,5,1,1,17,3,141,87,4,0,0,159,127,1,17,8,136,26,11,1,5,0,0,160,0,2,133, +32,16,1,17,2,143,108,12,1,17,3,141,91,9,1,1,17,6,136,28,14,0,0,160,0,1,133,35, +18,1,17,5,141,91,133,36,18,145,66,146,63,2,19,0,1,17,2,143,72,141,92,1,17,4, +141,91,132,126,141,92,1,1,17,2,136,32,0,0,129,127,1,17,3,141,90,129,126,141, +91,1,17,3,141,90,3,1,1,17,3,143,54,130,0,145,68,1,17,3,141,91,133,3,1,1,17,3, +141,88,5,141,89,1,17,5,141,88,141,92,130,3,141,91,1,1,17,9,141,88,0,0,160,0, +8,5,133,6,144,115,3,145,23,1,1,17,2,141,99,1,1,17,6,136,40,133,8,144,118,144, +117,130,3,142,77,1,17,2,145,18,1,1,17,2,143,53,145,70,1,17,4,141,90,130,3,1, +0,0,160,0,1,17,3,141,90,3,1,1,17,2,145,74,1,1,17,3,142,100,133,55,36,1,17,2, +141,92,145,75,1,17,3,141,97,130,14,1,1,17,3,141,97,129,102,1,1,17,6,141,94,129, +103,4,9,1,0,0,160,0,1,17,2,141,94,1,1,17,3,141,94,133,35,1,1,17,4,141,94,8,1, +0,0,159,127,1,17,3,141,93,130,20,141,94,1,17,3,141,93,129,108,1,1,17,4,141,93, +28,3,1,1,17,2,141,93,1,1,17,4,136,22,30,19,1,1,17,2,145,36,136,58,1,17,2,141, +94,1,1,17,3,136,59,130,24,1,1,17,2,145,39,136,59,1,17,2,143,1,1,1,17,3,136,60, +130,27,1,1,17,2,145,94,1,1,17,3,141,98,130,19,141,99,1,17,4,141,98,130,33,1, +0,0,160,0,1,17,3,141,98,3,1,1,17,3,141,98,43,1,1,17,4,141,98,43,143,1,1,1,17, +2,141,97,142,111,1,17,3,136,67,130,35,1,1,17,2,145,50,1,1,17,3,141,99,130,37, +144,110,1,17,2,141,99,1,1,17,2,145,53,1,1,17,3,141,100,4,1,1,17,2,145,107,1, +1,17,4,141,101,130,42,145,96,0,0,160,0,1,17,3,141,110,2,1,1,17,3,141,102,55, +1,1,17,2,145,111,1,1,17,2,145,107,1,1,17,2,145,108,2,1,17,4,136,79,130,48,2, +1,1,17,4,141,106,132,66,1,0,0,159,127,1,17,3,145,13,60,1,1,17,2,144,94,129,84, +1,17,3,142,81,19,1,1,17,2,144,96,129,83,1,17,3,142,83,4,1,1,17,4,141,111,31, +1,136,32,2,3,0,2,3,2,124,124,1,18,2,134,18,0,0,32,1,17,2,145,65,1,1,18,2,133, +125,1,2,3,1,124,2,3,1,124,2,3,14,78,111,116,32,97,32,115,121,109,98,111,108, +58,32,1,17,3,141,118,115,2,1,17,4,141,118,116,1,4,1,17,4,141,118,6,1,9,1,17, +6,141,118,105,1,11,133,113,4,1,17,3,141,116,130,68,141,117,1,17,3,141,116,130, +60,1,1,17,2,145,84,1,1,17,2,141,117,1,1,17,3,141,115,141,117,141,116,1,17,2, +136,103,141,114,1,17,2,145,80,1,1,17,2,145,89,136,104,1,17,2,144,119,1,1,17, +2,141,117,142,75,1,17,7,136,106,4,146,16,130,78,2,145,100,1,1,17,3,141,118,145, +101,1,1,17,2,141,118,118,1,17,5,141,118,142,8,2,142,122,1,1,17,3,141,118,142, +123,1,1,17,2,146,21,1,2,3,26,114,115,101,116,58,32,111,117,116,32,111,102,32, +108,105,115,116,32,115,101,116,116,105,110,103,32,1,17,3,141,118,130,88,141, +119,1,17,3,141,118,130,89,1,1,17,3,141,118,130,78,1,1,17,2,141,118,145,41,1, +17,3,146,17,130,89,1,1,17,2,141,120,141,119,1,17,5,141,119,130,94,2,130,91,1, +1,17,3,141,119,130,80,1,1,17,3,136,120,132,126,1,1,17,2,145,100,1,1,17,2,141, +120,141,121,1,17,5,141,119,130,96,1,2,141,120,1,17,5,141,119,134,15,13,130,87, +1,1,17,2,145,112,1,1,17,2,141,120,145,102,1,17,2,141,120,1,1,17,2,145,115,1, +1,17,2,143,77,1,1,17,2,141,122,1,1,17,2,145,118,1,1,17,3,145,37,1,136,82,1,17, +2,145,72,0,13,4,2,3,5,35,116,114,117,101,2,3,6,35,102,97,108,115,101,2,3,11, +35,60,102,117,110,99,116,105,111,110,62,2,3,6,35,60,87,84,70,62,2,3,5,35,116, +114,117,101,2,3,6,35,102,97,108,115,101,2,3,2,35,60,2,3,1,62,2,3,11,35,60,102, +117,110,99,116,105,111,110,62,2,3,6,35,60,87,84,70,62,1,17,3,142,37,130,117, +142,38,1,17,3,142,37,130,109,1,1,17,2,146,5,1,1,17,2,142,38,1,1,17,3,142,4,134, +21,146,59,1,17,3,142,4,2,1,1,17,2,145,38,133,103,1,17,5,142,5,133,102,2,130, +127,1,1,17,3,142,5,133,107,1,1,17,2,142,5,1,1,17,3,142,5,146,66,1,1,17,3,142, +5,0,13,3,1,1,17,2,144,81,133,91,1,17,3,144,101,2,1,1,17,2,145,110,134,10,1,17, +5,142,5,0,13,3,129,86,1,22,1,17,2,142,4,142,5,1,17,5,142,4,28,2,142,18,1,1,17, +2,142,6,142,4,1,17,5,142,4,142,26,2,142,20,1,1,17,2,142,8,142,4,1,17,5,142,6, +142,26,2,142,22,1,1,17,2,142,10,137,11,1,17,5,142,8,142,29,2,69,1,1,17,2,142, +6,142,7,1,17,5,142,10,142,64,2,133,104,1,1,17,2,142,8,142,7,1,17,6,142,7,0,13, +3,134,4,2,39,1,1,17,2,142,7,137,16,1,17,2,142,6,142,7,1,17,4,142,6,134,47,2, +1,1,17,6,137,18,142,55,4,130,91,1,0,32,1,1,17,2,142,11,137,21,1,17,2,142,10, +142,11,1,17,4,142,10,134,51,2,1,1,17,6,137,21,137,31,4,130,95,1,0,32,1,1,17, +4,142,11,142,75,1,44,1,17,2,142,19,142,20,1,17,5,142,12,83,2,100,1,1,17,5,142, +12,142,100,1,89,144,88,1,17,2,146,8,134,36,1,17,3,142,34,129,112,1,1,17,6,142, +14,142,86,3,51,52,1,1,17,2,142,22,142,21,1,17,3,142,13,142,14,1,1,17,3,142,13, +146,56,1,1,17,5,142,13,146,58,4,142,17,1,1,17,4,142,13,146,58,1,129,119,1,17, +4,142,13,143,78,1,131,41,1,17,3,142,13,138,20,1,1,17,2,146,105,1,1,17,3,142, +13,134,47,146,26,1,17,8,142,13,0,13,3,2,146,27,129,123,1,53,146,27,1,17,5,142, +13,64,1,3,146,28,1,17,5,142,14,142,61,1,4,146,29,1,17,5,142,15,142,60,1,5,146, +30,1,17,2,137,41,146,31,1,17,3,137,41,137,46,1,1,17,5,137,41,142,64,3,104,1, +1,17,2,142,18,142,42,1,17,5,137,42,142,99,2,134,11,1,1,17,2,142,20,142,42,1, +17,7,142,20,0,13,3,146,37,134,39,2,74,1,1,17,8,142,20,13,65,146,38,134,72,146, +38,67,66,1,17,5,142,20,142,88,2,134,35,1,1,17,2,142,24,142,48,1,17,5,142,21, +111,2,129,0,1,1,17,3,142,29,17,146,42,1,17,5,142,22,143,1,2,118,1,1,17,3,142, +31,134,65,146,44,1,17,3,144,83,130,13,1,1,17,6,142,24,142,115,3,76,77,1,1,17, +2,142,22,146,47,1,17,2,142,22,142,51,1,17,2,142,22,1,1,17,4,142,22,142,26,3, +1,1,17,3,142,22,134,43,147,8,1,17,3,142,22,131,66,1,1,17,2,142,22,1,1,17,2,142, +22,1,1,17,3,144,119,134,16,1,1,17,3,142,22,31,142,23,1,17,4,142,22,2,146,57, +1,1,17,3,142,22,131,62,1,1,17,5,142,22,146,95,9,131,91,1,1,17,4,142,22,146,60, +134,56,1,1,17,5,142,22,146,98,15,142,38,1,1,17,6,142,21,146,98,1,130,29,142, +22,146,62,1,17,5,142,21,143,118,1,131,81,146,63,1,17,3,142,21,39,142,72,1,17, +3,142,36,134,57,147,22,1,17,3,142,36,131,80,1,1,17,2,142,23,1,1,17,3,142,23, +4,1,1,17,4,142,23,44,142,77,146,69,1,17,5,142,23,134,31,2,131,102,1,1,17,6,142, +23,142,59,138,67,8,131,75,1,1,17,3,142,23,134,68,1,1,17,3,142,23,146,101,1,1, +17,2,142,23,0,13,3,1,17,3,142,23,142,124,1,1,17,3,142,24,146,111,1,1,17,3,142, +25,142,108,1,1,17,3,142,26,142,108,1,1,17,3,142,27,142,111,1,1,17,3,142,28,129, +22,1,1,17,3,142,29,146,118,1,1,17,3,142,30,144,9,1,1,17,3,146,60,138,79,1,1, +17,3,142,30,1,142,31,1,17,3,143,13,142,116,146,64,1,17,3,142,34,142,116,1,1, +17,3,142,35,142,119,1,1,17,2,145,54,147,46,1,17,4,142,34,143,30,2,1,1,17,3,146, +67,129,32,1,1,17,3,142,35,131,108,145,88,1,17,3,142,35,134,84,1,1,17,3,142,35, +0,13,3,1,1,17,4,144,70,135,8,1,142,35,1,17,4,143,59,107,1,5,1,17,2,147,43,12, +1,17,3,142,37,1,142,113,1,17,4,142,37,0,13,3,3,1,1,17,2,142,37,1,1,17,3,143, +98,27,1,1,17,2,145,67,131,10,1,17,2,142,39,1,1,17,2,142,41,1,1,17,3,143,102, +4,1,1,1,2,0,13,0,0,13,0,1,17,3,145,62,134,125,147,63,1,17,3,142,43,134,126,1, +1,17,2,142,43,1,1,17,4,142,41,4,1,142,42,2,3,7,10,32,32,32,32,32,32,1,1,2,0, +0,10,0,13,0,1,1,2,0,0,10,0,13,0,1,1,2,0,0,10,0,13,0,1,1,2,0,0,10,0,13,0,1,17, +2,142,46,135,57,1,17,2,142,46,135,58,1,17,3,143,113,130,38,1,1,17,4,142,45,135, +21,142,47,142,46,1,17,3,142,45,131,76,1,1,17,2,142,45,135,62,1,17,4,142,45,143, +25,1,135,63,1,17,3,143,72,143,24,1,1,17,6,138,35,135,43,142,46,0,12,131,255, +127,4,145,69,1,17,3,142,46,2,1,1,17,2,138,36,1,1,17,2,147,78,1,1,17,2,142,48, +143,28,1,17,3,142,48,11,1,1,17,2,142,50,143,30,1,17,3,142,49,13,1,1,17,4,142, +48,135,51,142,49,0,12,131,255,127,1,17,3,142,48,135,74,1,1,17,2,147,33,1,1,17, +2,142,49,1,1,17,2,142,47,143,34,1,17,2,138,46,1,1,17,2,146,33,147,88,1,17,4, +142,48,132,24,1,142,49,1,17,3,142,48,132,15,1,1,17,3,142,48,147,46,1,1,17,2, +147,41,1,1,17,2,138,51,1,1,17,2,142,49,135,86,1,17,5,142,49,135,84,142,51,132, +27,1,1,17,3,138,53,135,74,1,1,17,2,147,95,1,1,17,4,142,50,135,77,142,51,148, +15,1,17,3,138,55,147,52,1,1,17,3,142,51,147,55,1,1,17,2,147,99,1,1,17,3,146, +3,9,147,86,1,17,3,142,53,2,147,87,1,17,4,144,103,135,83,1,148,23,1,17,3,142, +54,147,58,1,1,17,3,145,65,9,1,1,17,5,142,55,147,62,1,14,147,91,1,17,5,142,55, +135,83,6,135,82,1,1,17,2,147,107,1,1,17,2,147,32,1,1,17,4,147,119,135,93,0,12, +131,255,127,1,1,17,2,142,58,135,101,1,17,3,142,58,2,1,1,17,2,145,121,48,1,17, +3,142,59,132,53,147,104,1,17,3,142,59,39,1,1,17,4,142,59,145,112,144,32,1,1, +17,3,142,59,147,75,1,1,17,2,146,27,1,1,17,6,142,60,135,89,147,117,0,12,131,255, +127,143,68,147,126,1,17,3,142,60,135,112,1,1,17,2,147,120,1,1,17,2,142,61,145, +5,1,17,3,142,61,2,1,1,17,2,147,123,1,1,17,2,142,96,143,75,1,17,3,142,89,135, +118,1,1,17,2,142,64,3,1,17,2,142,64,1,1,17,3,144,49,3,1,1,17,3,142,64,54,142, +65,1,17,2,142,64,55,1,17,5,142,64,0,0,160,0,135,73,2,1,1,17,2,147,75,1,1,17, +2,142,65,1,1,17,2,142,65,2,1,17,5,142,65,135,92,1,129,33,75,1,17,2,142,67,4, +1,17,3,144,74,129,35,1,1,17,3,147,99,1,0,12,1,1,17,3,142,68,7,0,12,1,1,17,7, +142,68,5,0,12,1,135,97,1,129,38,79,1,17,2,142,72,9,1,17,5,142,69,135,99,1,129, +40,80,1,17,3,142,72,11,0,12,1,1,17,5,142,70,135,101,1,129,42,81,1,17,2,142,70, +136,10,1,17,3,142,70,1,87,1,17,3,144,68,2,1,1,17,2,142,71,136,13,2,3,12,101, +110,100,32,111,102,32,105,110,112,117,116,2,3,8,98,97,100,32,98,121,116,101, +2,3,1,58,2,3,1,32,2,3,1,58,2,3,1,32,2,3,11,111,117,116,32,111,102,32,100,97, +116,97,2,3,5,105,110,112,117,116,1,1,2,148,74,0,13,0,1,1,2,149,17,1,1,1,2,0, +0,32,0,13,0,1,1,2,0,0,32,1,1,1,2,0,0,32,1,1,1,2,0,0,10,0,13,0,1,1,2,0,0,39,1, +1,1,2,0,0,10,0,13,0,1,1,2,0,0,94,1,1,17,4,142,84,145,24,132,106,142,85,1,17, +4,142,84,18,147,126,1,1,17,2,147,111,1,1,17,2,142,84,142,85,1,17,2,142,84,20, +1,17,2,142,84,1,1,17,3,142,84,4,1,1,17,2,145,111,1,1,17,2,142,85,16,1,17,3,142, +85,7,1,1,17,2,145,114,1,1,17,3,142,84,132,104,142,85,1,17,2,142,84,1,1,17,2, +142,84,1,1,17,2,145,116,1,1,17,3,142,84,135,123,146,123,1,17,4,142,84,148,13, +147,84,1,1,17,3,142,84,142,87,1,1,17,2,142,84,1,1,17,2,145,121,1,1,17,2,142, +85,1,1,17,2,142,85,2,1,17,4,142,79,55,0,12,2,23,1,17,4,142,79,56,1,0,12,2,1, +17,4,142,80,136,16,1,142,79,1,17,3,142,79,132,71,1,1,17,3,142,79,133,4,1,1,17, +4,142,79,60,1,0,12,2,1,17,4,145,76,136,10,1,31,1,17,3,142,80,132,27,1,1,17,5, +142,80,63,1,0,12,2,35,1,17,4,142,80,62,1,0,12,2,1,17,2,147,50,1,1,17,3,142,81, +133,8,1,1,17,3,142,81,136,14,1,1,17,3,148,34,64,0,12,2,1,17,2,147,54,5,1,17, +3,148,71,133,12,1,1,17,3,142,83,133,16,1,1,17,3,142,83,133,14,1,1,17,3,147,18, +132,105,1,1,17,3,142,84,136,21,1,1,17,3,143,75,133,20,142,84,1,17,8,142,84,136, +33,2,71,56,55,133,21,1,1,17,5,142,84,133,22,142,90,133,8,1,1,17,4,142,84,145, +117,133,11,1,1,17,8,142,84,136,36,12,11,61,60,148,43,1,1,17,2,142,84,1,1,17, +2,142,84,148,72,1,17,3,142,84,148,46,1,1,17,2,148,88,1,1,17,2,143,10,148,75, +1,17,3,143,10,148,49,1,1,17,2,148,91,1,1,17,2,142,88,65,1,17,3,142,88,2,1,1, +17,2,147,74,25,1,17,2,147,118,10,1,17,5,142,90,133,33,2,68,1,1,17,5,142,90,9, +147,127,1,148,68,1,17,3,142,90,5,1,2,3,17,104,111,119,32,100,111,32,105,32,105, +116,101,114,97,116,101,32,1,17,2,142,90,145,86,1,17,3,142,90,148,60,1,1,17,2, +148,45,1,1,17,2,142,91,145,89,1,17,3,142,91,148,63,1,1,17,2,142,89,142,90,1, +17,4,142,89,1,136,25,142,92,1,17,3,142,89,148,66,1,1,17,2,148,114,1,1,17,2,142, +89,148,11,1,17,2,142,89,1,1,17,2,142,88,142,89,1,17,2,142,88,148,14,1,17,3,142, +88,1,148,64,1,17,2,142,88,1,1,17,3,142,88,133,52,146,78,1,17,2,139,73,1,1,17, +2,142,89,1,1,17,2,142,94,148,20,1,17,3,142,92,133,56,146,82,1,17,3,139,76,2, +1,1,17,2,142,93,1,1,17,2,148,73,142,93,1,17,4,142,92,1,142,93,148,125,1,17,2, +148,75,1,1,17,3,142,92,1,142,93,1,17,2,142,92,1,1,17,3,142,92,133,67,1,1,17, +3,142,92,148,85,1,1,17,2,149,4,142,91,1,1,2,0,0,0,0,13,0,1,1,2,1,0,13,0,1,17, +3,142,93,1,142,95,1,17,3,142,94,2,142,93,1,17,4,142,92,148,125,2,142,93,1,17, +4,142,92,3,148,94,1,1,17,2,149,11,1,1,17,4,142,93,136,120,38,131,41,1,17,4,142, +93,145,19,1,132,46,1,17,3,142,93,145,117,1,1,17,3,148,40,148,99,1,1,17,2,149, +11,5,1,17,3,142,95,2,1,1,17,2,149,13,11,1,17,3,142,97,4,1,1,17,3,146,41,132, +9,144,85,1,17,3,142,98,136,88,1,1,17,2,142,98,149,21,1,17,3,146,25,132,12,1, +1,17,3,142,99,136,91,1,1,17,4,142,99,146,56,17,1,1,17,4,142,99,5,148,110,1,1, +17,2,148,95,1,1,17,2,142,100,1,1,17,3,142,100,14,1,1,17,2,142,100,136,99,1,17, +3,149,25,27,1,1,17,3,142,101,133,94,1,1,17,2,142,101,1,1,17,3,142,101,136,116, +1,1,17,2,148,12,1,1,17,3,142,102,2,1,1,17,5,142,102,149,36,38,1,32,1,17,4,142, +102,149,21,30,1,1,17,3,142,102,148,123,1,1,17,2,142,102,1,1,17,2,142,102,1,1, +17,2,147,56,132,31,1,17,3,142,103,3,1,1,17,5,142,103,29,3,132,77,1,1,17,3,142, +103,146,20,1,1,18,2,67,0,0,46,1,17,2,148,115,1,2,3,10,98,97,100,32,100,105,103, +105,116,32,1,17,2,145,21,133,99,1,17,3,142,103,133,100,1,1,24,2,0,0,48,0,0,0, +1,24,2,0,0,50,0,0,2,1,24,2,0,0,52,0,0,4,1,24,4,0,0,49,0,0,1,3,2,1,24,2,0,0,54, +0,0,6,1,24,2,0,0,56,0,0,8,1,24,4,0,0,53,0,0,5,4,2,1,24,2,0,0,65,0,0,10,1,24, +2,0,0,67,0,0,12,1,24,4,0,0,57,0,0,9,4,2,1,24,4,0,0,51,0,0,3,7,4,1,24,2,0,0,69, +0,0,14,1,24,2,0,0,97,0,0,10,1,24,4,0,0,68,0,0,13,5,2,1,24,2,0,0,99,0,0,12,1, +26,2,0,0,102,0,0,15,1,25,3,0,0,101,0,0,14,1,1,26,4,0,0,100,0,0,13,3,1,1,24,4, +0,0,98,0,0,11,6,1,1,26,4,0,0,70,0,0,15,6,1,1,24,4,0,0,66,0,0,11,11,1,1,24,4, +0,0,55,0,0,7,11,1,1,17,2,142,124,23,1,17,2,148,115,133,126,1,17,4,142,125,136, +119,1,3,1,17,3,142,125,3,1,1,17,2,148,118,134,14,1,17,5,142,126,134,9,1,137, +58,30,1,17,4,142,126,134,0,148,106,1,1,17,3,144,42,149,86,1,1,17,4,142,127,136, +125,1,9,1,17,3,142,127,137,44,1,1,18,2,129,33,0,0,43,1,18,2,129,34,0,0,45,1, +17,2,143,126,0,0,43,1,18,3,129,32,2,1,1,18,3,129,33,4,1,1,17,3,143,4,6,148,27, +1,17,2,143,18,1,1,17,3,143,14,129,28,1,1,17,3,143,15,129,43,1,1,17,3,143,7,16, +1,1,17,2,147,28,1,1,17,3,143,8,134,28,148,33,1,17,2,143,24,1,1,17,3,143,118, +3,1,1,17,3,144,6,10,1,1,17,2,147,33,1,1,17,3,143,119,133,72,148,38,1,17,2,143, +29,1,1,17,3,143,14,3,1,1,17,2,143,31,1,1,17,3,143,15,129,52,1,1,17,3,143,15, +129,49,1,1,17,3,143,15,129,61,1,1,17,2,143,15,134,40,1,17,4,143,15,149,109,1, +148,46,1,17,3,144,1,21,1,1,17,2,143,36,148,48,1,17,3,143,17,134,41,1,1,17,3, +143,17,134,48,1,1,17,2,143,38,1,1,17,3,143,18,8,1,1,17,2,143,40,1,1,17,3,147, +10,134,44,148,54,1,17,3,149,106,133,89,1,1,17,3,143,21,134,13,1,1,17,3,143,21, +36,1,1,17,2,143,48,1,1,17,3,143,44,129,59,1,1,17,3,143,45,129,73,1,1,17,3,143, +35,46,1,1,17,2,143,52,1,1,17,3,143,26,129,73,1,1,17,4,143,26,129,70,11,1,1,17, +3,143,26,129,82,1,1,17,2,143,55,1,1,17,3,143,27,35,1,1,17,3,144,36,21,1,1,17, +2,147,65,1,1,17,2,143,28,129,30,1,17,3,146,51,2,1,1,17,2,149,46,1,1,17,3,146, +50,133,22,1,1,17,3,143,31,1,140,87,2,3,9,109,99,112,47,108,105,110,107,115,2, +3,9,109,99,112,47,98,114,101,97,107,2,3,18,115,116,111,112,112,105,110,103,32, +111,110,32,115,105,103,110,97,108,1,17,2,143,34,137,125,1,17,5,143,34,130,2, +1,0,12,2,2,2,3,40,111,108,58,32,100,114,111,112,112,105,110,103,32,101,110,118, +101,108,111,112,101,32,116,111,32,109,105,115,115,105,110,103,32,116,104,114, +101,97,100,10,2,3,13,111,108,58,32,101,110,118,101,108,111,112,101,32,2,3,4, +114,118,97,108,2,3,19,102,111,114,107,58,32,98,97,100,32,112,97,114,97,109,101, +116,101,114,2,3,49,115,121,115,99,97,108,108,32,49,52,32,45,32,109,101,109,108, +105,109,105,116,32,101,120,99,101,101,100,101,100,44,32,100,114,111,112,112, +105,110,103,32,97,32,116,104,114,101,97,100,2,3,27,98,97,100,32,115,121,115, +99,97,108,108,32,111,112,32,119,105,116,104,105,110,32,112,97,114,58,32,2,3, +7,71,79,78,68,79,82,33,2,3,7,71,79,78,68,79,82,33,1,1,2,0,0,10,0,13,0,1,17,3, +143,36,129,127,144,40,1,17,3,145,89,133,11,1,1,17,3,145,90,133,12,1,1,17,4,141, +92,131,48,1,4,1,17,4,141,106,130,3,1,12,1,17,2,143,40,149,75,1,17,3,143,40,137, +70,143,44,1,17,9,141,95,130,6,3,16,137,71,2,130,100,145,11,1,1,17,3,143,41,149, +114,1,1,17,3,143,41,137,75,1,1,17,3,143,40,1,143,41,1,17,2,146,64,1,1,17,2,141, +120,137,78,1,17,5,141,104,137,79,1,27,0,13,3,1,17,2,143,42,3,1,17,3,143,72,137, +46,1,1,17,4,143,43,137,80,1,30,1,17,3,147,65,137,48,1,1,17,7,141,105,137,49, +143,47,137,84,1,32,0,13,3,1,17,3,141,105,6,1,1,17,2,143,46,150,41,1,17,2,150, +43,1,1,17,2,143,47,3,1,17,3,143,47,2,1,1,17,3,143,47,3,1,1,17,2,143,46,143,47, +1,17,2,150,48,1,1,17,3,143,46,8,151,37,1,17,3,141,113,9,151,36,1,17,5,141,113, +137,91,1,36,0,0,127,1,17,3,148,96,137,92,44,1,17,3,143,49,137,93,1,1,17,12,143, +49,150,109,137,98,1,46,0,13,3,150,108,137,94,130,125,130,32,150,22,38,1,17,5, +143,49,138,19,143,62,1,149,103,1,17,3,143,53,15,151,60,1,17,3,143,50,137,97, +143,64,1,17,2,143,50,151,52,1,17,5,143,50,138,13,2,145,41,1,1,17,4,143,50,137, +104,1,131,3,1,17,3,143,50,150,16,150,66,1,17,2,143,50,1,1,17,2,141,124,149,111, +1,17,3,150,53,138,5,1,1,17,4,141,125,138,16,1,144,112,1,17,4,141,125,138,17, +1,144,113,1,17,2,143,59,151,49,1,17,4,143,54,37,143,55,1,1,17,5,143,53,137,113, +143,54,60,57,1,17,3,143,53,138,11,1,1,17,5,143,52,137,111,143,78,62,143,88,1, +17,7,143,52,137,112,143,79,143,88,137,114,143,79,149,120,1,17,3,143,52,131,12, +1,1,17,4,143,52,137,118,1,131,17,1,17,4,143,52,34,151,61,151,17,1,17,4,143,52, +130,54,1,59,1,17,2,143,52,151,17,1,17,4,142,8,32,151,16,1,1,17,2,143,71,151, +11,1,17,2,143,54,1,1,17,3,143,54,150,1,1,1,17,2,143,74,151,12,1,17,2,143,55, +150,3,1,17,3,147,112,36,1,1,17,4,143,56,3,138,26,1,1,17,2,143,55,143,56,1,17, +3,143,55,138,49,1,1,17,4,143,54,138,50,1,143,55,1,17,5,143,54,138,1,143,96,74, +150,9,1,17,2,143,82,150,111,1,17,2,143,55,1,1,17,5,143,55,137,101,143,99,150, +112,150,12,1,17,4,143,55,137,102,1,150,115,1,17,4,143,55,138,10,1,150,116,1, +17,4,143,55,138,11,1,150,115,1,2,22,143,94,47,45,41,40,36,34,30,28,26,143,78, +25,22,20,18,15,11,8,7,5,1,142,25,1,17,3,143,56,138,13,82,1,17,3,143,55,132,88, +143,56,1,17,3,147,26,146,78,1,1,17,2,150,100,1,1,17,4,143,57,138,15,143,116, +150,121,1,17,3,143,57,138,14,1,1,17,3,143,123,135,40,1,1,17,3,143,58,138,20, +1,1,17,4,143,58,138,21,1,150,125,1,17,4,143,58,6,1,150,122,1,17,3,147,24,146, +91,1,1,17,2,143,100,150,126,1,17,2,143,73,1,1,17,4,143,61,138,22,143,117,151, +2,1,17,2,143,103,151,2,1,17,2,143,62,16,1,17,3,143,62,138,105,1,1,17,4,143,62, +17,7,1,1,17,7,143,62,138,27,5,0,13,3,151,9,4,1,1,2,22,143,114,67,65,61,60,56, +54,50,48,46,143,98,45,42,40,38,35,31,28,27,1,7,142,45,1,17,2,142,44,138,100, +1,17,2,142,44,1,1,17,5,142,43,1,130,104,142,44,101,1,17,6,142,43,150,41,142, +48,138,112,1,0,0,206,16,1,17,2,150,118,1,1,17,2,142,73,102,1,17,4,142,45,130, +108,1,104,1,17,2,143,74,8,1,17,7,142,46,28,4,2,138,117,1,0,0,206,16,1,17,2,143, +72,1,1,17,3,147,46,138,24,1,1,17,2,150,41,135,65,1,17,4,143,73,135,60,1,0,0, +135,104,1,40,2,0,0,2,0,13,0,1,40,2,0,0,130,233,171,36,1,1,40,2,0,0,131,185,187, +41,1,1,40,2,0,0,132,241,227,71,1,2,3,16,98,97,100,32,114,97,110,100,32,108,105, +109,105,116,58,32,2,3,19,114,97,110,100,45,101,108,101,109,58,32,119,104,97, +116,32,98,101,32,2,3,22,114,110,100,45,114,97,110,103,101,58,32,98,97,100,32, +114,97,110,103,101,58,32,1,17,2,151,9,143,80,1,17,2,141,89,1,1,17,2,151,8,1, +1,17,2,143,82,0,0,129,191,159,25,1,17,2,150,89,1,1,17,4,141,68,1,143,83,0,0, +132,128,128,9,1,17,4,141,68,135,74,1,10,1,17,4,143,83,3,143,84,0,0,132,128,128, +9,1,17,4,141,69,4,143,86,0,0,132,128,128,9,1,17,7,141,69,5,143,87,0,0,132,128, +128,9,2,0,0,129,191,159,25,1,1,17,8,141,69,135,84,4,6,143,88,0,0,132,128,128, +9,135,72,1,1,17,2,143,86,148,29,1,17,3,145,55,2,1,1,17,2,151,19,1,1,17,3,148, +45,136,101,141,72,1,17,4,141,72,135,83,1,0,0,135,255,255,127,1,17,3,141,72,134, +123,1,1,17,2,151,21,1,1,17,6,141,72,0,0,135,255,255,127,134,125,141,73,135,92, +1,1,17,3,141,72,17,151,33,1,17,3,141,73,18,151,34,1,17,7,141,72,5,2,3,1,135, +0,141,73,1,17,2,141,72,1,1,17,5,141,110,7,1,139,12,26,1,17,3,143,98,133,109, +151,38,1,17,3,151,28,2,1,1,17,5,143,99,139,15,28,133,107,1,1,17,3,143,98,135, +101,143,99,1,17,5,143,98,147,43,2,5,1,1,17,3,143,103,135,76,151,43,1,17,3,151, +33,7,1,1,17,5,143,100,147,24,3,135,64,1,1,17,3,143,100,150,125,1,1,17,3,143, +100,137,120,151,47,1,17,3,143,100,11,1,1,17,3,148,64,138,3,1,1,17,3,141,122, +135,107,1,1,17,3,143,101,135,111,147,115,1,17,3,143,101,133,11,1,1,17,3,143, +101,135,100,1,1,17,4,143,101,143,105,17,1,1,17,5,143,101,133,7,151,55,151,6, +1,1,17,2,149,72,1,1,17,3,143,102,133,27,144,71,1,17,4,143,102,143,109,135,118, +1,1,17,2,143,102,3,1,17,5,143,102,151,11,2,135,120,1,1,17,5,143,102,133,13,151, +61,135,109,1,1,17,2,149,78,1,1,17,2,143,103,1,1,17,3,143,103,14,149,65,1,17, +3,143,103,28,1,1,17,3,143,103,135,114,1,1,17,3,143,120,135,127,151,67,1,17,3, +151,57,31,1,1,17,5,143,105,139,44,56,135,126,1,1,17,3,143,105,135,117,1,1,17, +3,143,104,135,36,143,105,1,17,4,143,102,139,18,150,38,141,107,1,17,4,143,102, +151,20,143,104,1,1,17,4,143,101,139,5,1,143,102,1,17,3,143,101,151,24,1,1,17, +2,151,11,1,1,17,3,143,102,1,151,20,1,17,4,143,102,135,60,1,143,110,1,17,4,143, +102,139,30,1,8,1,17,2,151,23,1,1,17,2,143,103,1,1,17,3,143,103,136,11,149,122, +1,17,3,143,103,46,1,1,17,3,143,103,136,4,1,1,17,2,143,103,1,1,17,3,144,11,136, +5,151,86,1,17,4,142,30,50,143,104,1,1,18,2,139,105,0,0,45,1,17,2,151,24,1,1, +24,2,0,0,45,0,13,2,1,24,2,0,13,1,1,1,18,3,139,106,139,105,1,1,18,3,139,99,0, +0,2,1,1,18,2,139,103,2,1,18,3,139,107,2,1,1,18,3,139,108,7,1,1,18,2,139,89,1, +2,3,3,110,97,110,2,3,28,109,97,110,100,97,116,111,114,121,32,111,112,116,105, +111,110,32,110,111,116,32,103,105,118,101,110,58,32,2,3,9,40,109,105,115,115, +105,110,103,41,2,3,2,45,45,2,3,1,39,2,3,23,39,32,114,101,113,117,105,114,101, +115,32,97,110,32,97,114,103,117,109,101,110,116,46,2,3,2,45,45,2,3,14,84,104, +101,32,97,114,103,117,109,101,110,116,32,39,2,3,18,39,32,100,105,100,32,110, +111,116,32,97,99,99,101,112,116,32,39,2,3,2,39,46,2,3,1,45,2,3,18,85,110,107, +110,111,119,110,32,97,114,103,117,109,101,110,116,58,32,2,3,2,32,32,2,3,3,32, +124,32,2,3,5,32,32,32,32,32,2,3,6,32,60,97,114,103,62,2,3,0,2,3,2,44,32,2,3, +0,2,3,1,93,2,3,2,32,91,2,3,0,2,3,12,32,40,109,97,110,100,97,116,111,114,121, +41,2,3,0,2,3,17,32,40,99,97,110,32,98,101,32,115,101,118,101,114,97,108,41,2, +3,0,2,3,11,32,40,116,101,114,109,105,110,97,108,41,2,3,0,1,1,2,0,0,10,0,13,0, +1,1,2,0,0,10,0,13,0,1,17,3,148,38,133,102,151,22,1,17,5,144,16,139,40,1,152, +26,144,17,1,17,3,144,16,133,104,1,1,17,4,144,16,139,42,1,152,29,1,17,2,151,127, +1,1,17,2,144,17,134,117,1,17,3,144,17,139,80,1,1,17,3,145,23,135,20,1,1,17,3, +151,28,39,1,1,17,4,144,19,131,124,144,77,0,12,2,1,17,5,146,56,139,87,1,133,28, +12,1,17,2,144,20,41,1,17,4,144,20,139,51,1,42,1,17,2,150,22,152,14,1,17,3,150, +42,2,1,1,17,4,144,25,132,2,144,83,0,12,2,1,17,6,144,23,139,93,1,133,34,17,45, +1,17,5,144,23,139,56,1,152,42,45,1,17,3,152,6,6,1,1,17,4,144,24,139,58,1,152, +49,1,17,4,144,24,139,59,1,152,97,1,17,3,149,45,139,106,1,1,17,2,150,122,139, +57,1,17,2,144,26,1,1,17,4,144,26,139,63,1,152,99,1,17,2,144,26,1,1,17,4,144, +26,139,65,1,152,99,1,17,4,144,26,139,66,1,152,106,1,17,4,144,26,14,152,101,1, +1,17,3,144,26,17,1,1,17,4,144,26,139,69,1,152,60,1,17,3,151,2,139,116,1,1,17, +3,150,31,139,94,144,26,1,17,3,144,26,2,1,1,17,3,144,26,24,53,1,17,6,144,26,135, +2,1,55,139,99,149,61,1,17,3,144,26,139,71,149,74,1,17,3,149,59,136,97,1,1,17, +5,144,27,28,61,60,59,1,17,2,144,27,63,1,17,2,144,27,139,104,1,17,3,144,31,139, +76,149,79,1,17,4,144,28,139,81,2,1,1,17,4,144,28,139,82,1,152,118,1,17,4,144, +28,151,118,5,1,1,17,6,144,28,151,121,7,139,84,1,152,78,1,17,2,144,28,1,1,17, +5,144,28,139,86,1,152,76,152,44,1,17,2,144,28,1,1,17,8,144,28,139,88,12,39,75, +74,151,125,1,1,17,4,144,28,139,89,1,152,80,1,17,6,144,28,43,16,139,90,1,153, +2,1,17,3,145,65,139,116,144,28,1,17,5,144,28,49,2,139,115,1,1,17,4,144,28,135, +21,1,81,1,17,5,144,28,34,22,144,50,1,1,17,2,151,119,1,1,17,4,144,29,132,42,144, +125,0,12,2,1,17,4,144,29,2,1,0,13,3,2,3,1,10,1,17,2,150,69,135,44,1,17,3,149, +81,135,41,74,1,17,5,144,32,140,11,135,42,73,72,1,17,5,144,32,140,12,133,81,81, +4,1,17,4,144,32,67,68,1,1,17,4,144,32,139,104,1,152,98,1,17,4,144,34,71,72,1, +1,17,4,144,33,139,106,1,153,14,1,17,4,144,33,75,76,1,1,17,4,144,33,139,108,1, +153,18,1,17,6,144,33,79,139,109,8,153,15,1,1,17,4,144,33,139,110,1,153,16,1, +17,6,144,33,84,139,111,11,153,33,1,1,17,4,144,33,139,112,1,153,34,1,17,4,144, +33,88,89,1,1,17,4,144,33,139,114,1,153,26,1,17,4,144,33,139,115,1,152,101,1, +17,5,144,33,93,135,57,94,1,1,17,4,144,33,139,117,1,152,104,1,17,4,144,33,140, +28,19,1,1,18,3,140,71,1,132,62,2,3,43,119,97,114,110,105,110,103,58,32,98,97, +100,32,85,84,70,45,56,32,105,110,32,99,111,109,109,97,110,100,32,108,105,110, +101,32,97,114,103,117,109,101,110,116,1,17,5,144,34,132,55,152,45,1,135,66,1, +17,3,148,16,136,0,1,1,17,4,146,96,136,43,1,142,118,1,17,3,151,105,135,102,1, +1,17,4,144,37,140,32,152,86,1,1,17,2,150,96,140,57,1,17,2,144,38,1,1,17,3,144, +38,132,98,1,1,17,7,144,38,129,86,153,75,133,28,130,76,130,73,1,2,3,1,46,2,3, +2,46,46,1,17,3,148,76,137,10,0,0,131,255,127,1,17,4,144,38,136,4,1,144,39,1, +17,3,149,8,135,59,1,1,17,2,144,38,152,74,1,17,4,144,38,134,71,1,5,1,17,4,144, +38,134,72,1,7,1,17,3,145,120,134,50,1,1,17,3,144,39,144,43,1,1,17,2,144,39,1, +1,17,3,144,39,7,1,1,17,3,151,92,1,150,53,2,3,10,103,101,110,101,114,97,116,111, +114,115,2,3,8,112,97,116,116,101,114,110,115,2,3,9,109,117,116,97,116,105,111, +110,115,2,3,3,105,110,102,2,3,8,105,110,102,105,110,105,116,121,2,3,2,45,49, +2,3,7,102,111,114,101,118,101,114,2,3,8,105,110,102,105,110,105,116,121,2,3, +11,82,97,100,97,109,115,97,32,48,46,52,2,3,37,85,115,97,103,101,58,32,114,97, +100,97,109,115,97,32,91,97,114,103,117,109,101,110,116,115,93,32,91,102,105, +108,101,32,46,46,46,93,2,3,130,29,82,97,100,97,109,115,97,32,105,115,32,97,32, +103,101,110,101,114,97,108,32,112,117,114,112,111,115,101,32,102,117,122,122, +101,114,46,32,73,116,32,109,111,100,105,102,105,101,115,32,103,105,118,101,110, +32,115,97,109,112,108,101,32,100,97,116,97,32,10,105,110,32,119,97,121,115,44, +32,119,104,105,99,104,32,109,105,103,104,116,32,101,120,112,111,115,101,32,101, +114,114,111,114,115,32,105,110,32,112,114,111,103,114,97,109,115,32,105,110, +116,101,110,100,101,100,32,116,111,32,112,114,111,99,101,115,115,32,10,116,104, +101,32,100,97,116,97,46,32,70,111,114,32,109,111,114,101,32,105,110,102,111, +114,109,97,116,105,111,110,44,32,114,101,97,100,32,116,104,101,32,102,105,110, +101,32,109,97,110,117,97,108,32,112,97,103,101,44,32,111,114,32,118,105,115, +105,116,10,118,105,115,105,116,32,104,116,116,112,58,47,47,99,111,100,101,46, +103,111,111,103,108,101,46,99,111,109,47,112,47,111,117,115,112,103,47,10,10, +82,97,100,97,109,115,97,32,119,97,115,32,119,114,105,116,116,101,110,32,98,121, +32,65,107,105,32,72,101,108,105,110,32,97,116,32,79,85,83,80,71,46,2,3,2,45, +104,2,3,6,45,45,104,101,108,112,2,3,15,115,104,111,119,32,116,104,105,115,32, +116,104,105,110,103,2,3,2,45,97,2,3,7,45,45,97,98,111,117,116,2,3,19,119,104, +97,116,32,105,115,32,116,104,105,115,32,116,104,105,110,103,63,2,3,2,45,86,2, +3,9,45,45,118,101,114,115,105,111,110,2,3,20,115,104,111,119,32,112,114,111, +103,114,97,109,32,118,101,114,115,105,111,110,2,3,14,111,117,116,112,117,116, +45,112,97,116,116,101,114,110,2,3,2,45,111,2,3,8,45,45,111,117,116,112,117,116, +2,3,1,45,2,3,61,111,117,116,112,117,116,32,112,97,116,116,101,114,110,44,32, +101,46,103,46,32,47,116,109,112,47,102,117,122,122,45,37,110,46,102,111,111, +44,32,45,44,32,58,56,48,32,111,114,32,49,50,55,46,48,46,48,46,49,58,56,48,2, +3,5,99,111,117,110,116,2,3,2,45,110,2,3,7,45,45,99,111,117,110,116,2,3,1,49, +2,3,44,104,111,119,32,109,97,110,121,32,111,117,116,112,117,116,115,32,116,111, +32,103,101,110,101,114,97,116,101,32,40,110,117,109,98,101,114,32,111,114,32, +105,110,102,41,2,3,4,115,101,101,100,2,3,2,45,115,2,3,6,45,45,115,101,101,100, +2,3,36,114,97,110,100,111,109,32,115,101,101,100,32,40,110,117,109,98,101,114, +44,32,100,101,102,97,117,108,116,32,114,97,110,100,111,109,41,2,3,2,45,109,2, +3,11,45,45,109,117,116,97,116,105,111,110,115,2,3,22,119,104,105,99,104,32,109, +117,116,97,116,105,111,110,115,32,116,111,32,117,115,101,2,3,2,45,112,2,3,10, +45,45,112,97,116,116,101,114,110,115,2,3,30,119,104,105,99,104,32,109,117,116, +97,116,105,111,110,32,112,97,116,116,101,114,110,115,32,116,111,32,117,115,101, +2,3,2,45,103,2,3,12,45,45,103,101,110,101,114,97,116,111,114,115,2,3,28,119, +104,105,99,104,32,100,97,116,97,32,103,101,110,101,114,97,116,111,114,115,32, +116,111,32,117,115,101,2,3,38,114,97,110,100,111,109,44,102,105,108,101,61,49, +48,48,48,44,106,117,109,112,61,50,48,48,44,115,116,100,105,110,61,49,48,48,48, +48,48,2,3,8,109,101,116,97,100,97,116,97,2,3,2,45,77,2,3,6,45,45,109,101,116, +97,2,3,48,115,97,118,101,32,109,101,116,97,100,97,116,97,32,97,98,111,117,116, +32,103,101,110,101,114,97,116,101,100,32,102,105,108,101,115,32,116,111,32,116, +104,105,115,32,102,105,108,101,2,3,2,45,114,2,3,11,45,45,114,101,99,117,114, +115,105,118,101,2,3,31,105,110,99,108,117,100,101,32,102,105,108,101,115,32, +105,110,32,115,117,98,100,105,114,101,99,116,111,114,105,101,115,2,3,2,45,108, +2,3,6,45,45,108,105,115,116,2,3,39,108,105,115,116,32,109,117,116,97,116,105, +111,110,115,44,32,112,97,116,116,101,114,110,115,32,97,110,100,32,103,101,110, +101,114,97,116,111,114,115,2,3,7,118,101,114,98,111,115,101,2,3,2,45,118,2,3, +9,45,45,118,101,114,98,111,115,101,2,3,31,115,104,111,119,32,112,114,111,103, +114,101,115,115,32,100,117,114,105,110,103,32,103,101,110,101,114,97,116,105, +111,110,2,3,12,47,100,101,118,47,117,114,97,110,100,111,109,2,3,14,77,117,116, +97,116,105,111,110,115,32,40,45,109,41,2,3,2,32,32,2,3,2,58,32,2,3,0,2,3,22, +77,117,116,97,116,105,111,110,32,112,97,116,116,101,114,110,115,32,40,45,112, +41,2,3,2,32,32,2,3,2,58,32,2,3,0,2,3,15,71,101,110,101,114,97,116,111,114,115, +32,40,45,103,41,2,3,78,32,115,116,100,105,110,58,32,114,101,97,100,32,100,97, +116,97,32,102,114,111,109,32,115,116,97,110,100,97,114,100,32,105,110,112,117, +116,32,105,102,32,110,111,32,112,97,116,104,115,32,97,114,101,32,103,105,118, +101,110,32,111,114,32,45,32,105,115,32,97,109,111,110,103,32,116,104,101,109, +2,3,33,32,102,105,108,101,58,32,114,101,97,100,32,100,97,116,97,32,102,114,111, +109,32,103,105,118,101,110,32,102,105,108,101,115,2,3,29,32,114,97,110,100,111, +109,58,32,103,101,110,101,114,97,116,101,32,114,97,110,100,111,109,32,100,97, +116,97,2,3,0,2,3,1,75,2,3,1,77,2,3,1,84,2,3,1,80,2,3,4,112,97,116,104,2,3,5, +99,108,111,115,101,2,3,13,82,97,110,100,111,109,32,115,101,101,100,58,32,2,3, +3,32,45,32,2,3,2,105,112,2,3,6,111,117,116,112,117,116,2,3,2,58,32,2,3,1,45, +2,3,29,67,97,110,110,111,116,32,111,112,101,110,32,109,101,116,97,100,97,116, +97,32,108,111,103,32,102,105,108,101,2,3,43,69,114,114,111,114,32,114,101,97, +100,105,110,103,32,115,97,109,112,108,101,32,102,105,108,101,115,46,32,84,111, +111,32,108,111,110,103,32,112,97,116,104,115,63,2,3,1,47,2,3,0,2,3,1,45,2,3, +3,110,116,104,1,4,1,90,1,4,1,90,1,4,1,90,1,1,2,87,0,13,0,1,1,2,89,1,1,1,2,91, +1,1,1,2,93,1,1,4,1,90,1,4,1,78,1,4,1,74,1,4,1,70,1,4,1,57,1,4,1,48,1,1,2,28, +0,13,0,1,1,2,30,1,1,1,2,32,1,1,1,2,34,1,1,1,2,36,1,1,1,2,0,0,10,0,13,0,1,4,1, +33,1,4,1,33,1,4,1,31,1,4,1,23,2,3,4,104,101,97,100,2,3,5,98,121,116,101,115, +1,40,2,0,0,149,215,71,0,13,0,1,40,2,0,0,130,248,218,99,1,1,40,2,0,0,192,128, +0,1,2,3,9,103,101,110,101,114,97,116,111,114,1,40,2,0,0,134,215,252,1,0,13,0, +1,40,2,0,0,134,251,190,93,1,1,40,2,0,0,129,210,156,84,1,1,40,2,0,0,152,163,71, +1,1,40,2,0,0,241,227,71,1,2,3,23,69,114,114,111,114,58,32,102,97,105,108,101, +100,32,116,111,32,111,112,101,110,32,39,2,3,65,39,46,32,80,108,101,97,115,101, +32,117,115,101,32,45,114,32,105,102,32,121,111,117,32,119,97,110,116,32,116, +111,32,105,110,99,108,117,100,101,32,115,97,109,112,108,101,115,32,102,114,111, +109,32,100,105,114,101,99,116,111,114,105,101,115,46,2,3,23,69,114,114,111,114, +58,32,102,97,105,108,101,100,32,116,111,32,111,112,101,110,32,39,2,3,1,39,2, +3,4,102,105,108,101,2,3,6,115,111,117,114,99,101,1,40,2,0,0,159,127,0,13,0,1, +40,2,0,0,135,255,255,127,1,2,3,4,106,117,109,112,1,18,2,132,125,0,0,61,1,17, +2,153,45,1,1,18,3,132,77,0,13,1,1,1,18,2,133,0,0,0,44,1,17,2,153,48,1,1,18,3, +132,80,0,13,1,1,2,3,1,45,2,3,5,115,116,100,105,110,2,3,1,45,2,3,4,102,105,108, +101,2,3,4,106,117,109,112,2,3,6,114,97,110,100,111,109,2,3,24,85,110,107,110, +111,119,110,32,100,97,116,97,32,103,101,110,101,114,97,116,111,114,58,32,2,3, +22,66,97,100,32,103,101,110,101,114,97,116,111,114,32,112,114,105,111,114,105, +116,121,2,3,13,110,111,32,103,101,110,101,114,97,116,111,114,115,1,4,1,35,1, +4,1,35,1,4,1,32,1,4,1,23,1,1,2,2,1,1,4,1,24,1,4,1,22,1,1,2,5,1,1,42,2,0,0,4, +0,0,5,2,3,14,66,97,100,32,112,114,105,111,114,105,116,121,58,32,2,3,15,73,110, +99,111,110,99,101,105,118,97,98,108,101,58,32,2,3,17,84,111,111,32,109,97,110, +121,32,116,104,105,110,103,115,58,32,2,16,3,0,3,119,1,17,2,1,141,46,2,16,3,0, +3,118,1,17,4,1,141,46,138,71,2,2,16,3,0,3,117,1,17,3,1,141,52,2,2,16,3,0,3,116, +2,16,3,0,3,115,2,16,3,0,3,114,1,17,3,1,138,74,2,1,17,2,4,1,2,16,3,0,3,113,2, +16,3,0,3,112,1,17,3,1,135,123,2,1,17,2,8,1,2,16,3,0,3,111,1,17,2,1,138,70,2, +16,3,0,3,110,1,17,5,1,134,4,146,94,0,12,2,19,2,16,3,0,3,109,1,17,5,1,134,6,146, +96,0,12,2,23,1,17,5,2,134,7,146,97,0,12,2,23,2,16,3,0,3,108,1,17,3,1,153,107, +2,2,16,3,0,3,107,1,17,5,1,153,109,5,138,80,2,2,16,3,0,3,106,1,17,3,1,132,24, +2,2,16,3,0,3,105,1,17,5,1,138,85,11,153,113,2,2,16,3,0,3,104,1,17,3,1,138,87, +2,2,16,3,0,3,103,1,17,3,1,138,60,2,2,16,3,0,3,102,1,17,4,1,138,100,28,153,118, +2,16,3,0,3,101,1,17,3,1,138,92,2,2,16,3,0,3,100,1,17,3,1,153,124,2,1,17,2,34, +1,2,16,3,0,3,99,2,16,3,0,3,98,2,16,3,0,3,97,1,17,2,1,2,2,16,3,0,3,96,1,17,4, +1,138,111,2,0,0,144,0,2,16,3,0,3,95,1,17,3,1,150,85,2,2,16,3,0,3,94,1,17,4,1, +138,72,2,0,0,144,0,2,16,3,0,3,93,2,16,3,0,3,92,1,17,6,1,138,77,3,0,0,144,0,150, +90,2,2,16,3,0,3,91,1,17,4,1,138,110,2,0,0,144,0,2,16,3,0,3,90,1,17,4,1,138,84, +16,2,2,16,3,0,3,89,1,40,2,0,0,129,0,0,13,0,1,40,2,0,0,0,1,1,40,2,0,0,127,0,13, +0,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,1,4,1,40,2,0,0,130,0,0,13,0,1,40,2, +0,0,0,1,1,40,2,0,0,129,127,0,13,0,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,1, +4,1,40,2,0,0,130,128,0,0,13,0,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0,129,255, +127,0,13,0,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,135,255,255,127,1,1,40,2, +0,0,1,5,1,40,2,0,0,132,128,0,0,13,0,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0, +131,255,127,0,13,0,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,135,255,255,127,1, +1,40,2,0,0,1,5,1,40,2,0,0,129,0,0,13,0,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2, +0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0,127,0,13,0,1,40,2,0,0,135,255, +255,127,1,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,135,255,255,127,1,1,40,2,0, +0,135,255,255,127,1,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,1,8,1,40,2,0,0,130, +0,0,13,0,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2,0,0,0,1,1,40,2, +0,0,0,1,1,40,2,0,0,129,127,0,13,0,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,135, +255,255,127,1,1,40,2,0,0,135,255,255,127,1,1,40,2,0,0,135,255,255,127,1,1,40, +2,0,0,135,255,255,127,1,1,40,2,0,0,1,8,1,11,33,2,8,1,15,21,14,28,31,27,35,38, +34,42,44,41,47,49,46,0,0,131,255,127,0,0,132,128,0,0,0,132,128,1,0,0,129,255, +127,0,0,130,128,0,0,0,130,128,1,0,0,129,127,0,0,130,0,0,0,130,1,0,0,127,0,0, +129,0,0,0,129,1,0,0,1,0,0,2,0,0,3,2,16,3,0,3,88,2,16,3,0,3,87,1,17,3,1,139,52, +2,2,16,3,0,3,86,1,17,3,1,139,51,4,1,17,3,4,139,52,5,2,16,3,0,3,85,1,17,3,1,131, +88,2,2,16,3,0,3,84,1,17,2,1,9,2,16,3,0,3,83,1,17,4,1,139,58,139,61,2,2,16,3, +0,3,82,1,17,3,1,131,94,2,2,16,3,0,3,81,1,17,3,1,131,67,2,2,16,3,0,3,80,1,17, +14,1,139,67,17,139,64,17,131,89,18,15,13,139,61,10,131,65,2,0,0,129,1,2,16,3, +0,3,79,1,17,3,1,131,100,2,2,16,3,0,3,78,2,16,3,0,3,77,1,17,2,1,90,1,17,2,3,1, +2,16,3,0,3,76,2,16,3,0,3,75,1,17,2,1,94,1,17,2,3,1,2,16,3,0,3,74,1,17,2,1,142, +54,2,16,3,0,3,73,1,17,3,1,142,60,2,2,16,3,0,3,72,1,17,4,1,142,108,2,0,13,3,2, +16,3,0,3,71,2,16,3,0,3,70,1,17,3,1,131,108,2,2,16,3,0,3,69,1,17,3,1,131,110, +2,2,16,3,0,3,68,1,17,3,1,131,112,2,2,16,3,0,3,67,2,16,3,0,3,66,1,17,3,1,142, +72,2,2,16,3,0,3,65,1,17,3,1,142,57,2,2,16,3,0,3,64,1,17,3,1,14,2,2,16,3,0,3, +63,1,17,3,1,16,2,2,16,3,0,3,62,2,16,3,0,3,61,1,17,3,1,139,99,2,2,16,3,0,3,60, +1,17,4,1,14,139,63,2,2,16,3,0,3,59,1,17,5,1,16,143,3,2,7,2,16,3,0,3,58,1,17, +4,1,132,11,2,18,2,16,3,0,3,57,1,17,3,1,139,97,2,2,16,3,0,3,56,1,17,3,1,0,0,134, +141,32,2,2,16,3,0,3,55,1,17,3,1,37,2,2,16,3,0,3,54,1,17,3,1,39,2,2,16,3,0,3, +53,1,17,3,1,45,68,2,16,3,0,3,52,1,17,3,1,4,2,2,16,3,0,3,51,1,17,4,1,139,103, +72,0,0,130,0,2,16,3,0,3,50,1,17,4,1,132,27,2,0,0,160,0,1,17,2,127,137,101,2, +16,3,0,3,49,1,17,4,1,137,70,2,143,55,2,16,3,0,3,48,1,17,4,1,137,72,2,143,57, +2,16,3,0,3,47,2,16,3,0,3,46,1,17,3,1,151,101,2,2,16,3,0,3,45,1,17,4,1,131,117, +2,0,0,130,0,2,16,3,0,3,44,1,17,3,1,132,39,2,2,16,3,0,3,43,1,17,3,1,142,32,2, +2,16,3,0,3,42,1,17,3,1,132,10,2,1,17,3,6,132,44,1,2,16,3,0,3,41,1,17,3,1,140, +15,2,2,16,3,0,3,40,2,16,3,0,3,39,2,16,3,0,3,38,1,17,3,1,140,19,2,2,16,3,0,3, +37,1,17,2,1,2,2,16,3,0,3,36,1,17,3,1,27,2,2,16,3,0,3,35,2,16,3,0,3,34,1,17,3, +1,140,23,2,2,16,3,0,3,33,1,17,3,1,13,129,46,2,16,3,0,3,32,1,17,4,1,15,140,30, +2,2,16,3,0,3,31,1,17,8,1,0,12,0,136,28,16,31,9,6,2,2,16,3,0,3,30,1,17,3,1,137, +53,2,2,16,3,0,3,29,1,17,3,1,136,13,2,2,16,3,0,3,28,1,17,2,1,2,2,16,3,0,3,27, +1,17,3,1,44,2,2,16,3,0,3,26,1,17,2,1,2,2,16,3,0,3,25,1,17,3,1,132,85,2,2,16, +3,0,3,24,1,17,2,1,2,2,16,3,0,3,23,1,17,4,1,132,79,2,130,23,2,16,3,0,3,22,2,16, +3,0,3,21,1,17,6,1,143,26,2,0,13,3,129,121,156,36,2,16,3,0,3,20,1,17,2,1,2,2, +16,3,0,3,19,1,17,3,1,139,75,2,2,16,3,0,3,18,1,17,4,1,9,2,0,12,0,2,16,3,0,3,17, +1,17,2,1,0,0,129,127,2,16,3,0,3,16,1,17,3,1,140,58,2,2,16,3,0,3,15,1,17,5,1, +152,32,129,13,139,96,2,1,17,2,122,1,2,16,3,0,3,14,2,16,3,0,3,13,1,17,2,1,2,2, +16,3,0,3,12,1,17,3,1,132,100,2,2,16,3,0,3,11,1,17,3,1,132,69,2,2,16,3,0,3,10, +1,17,3,1,9,2,2,16,3,0,3,9,1,17,4,1,132,73,2,0,0,160,0,1,17,2,129,2,1,2,16,3, +0,3,8,1,17,6,1,143,53,29,0,13,3,130,20,156,27,2,16,3,0,3,7,1,17,3,1,4,2,2,16, +3,0,3,6,1,17,3,1,132,123,2,1,17,4,88,132,114,1,130,52,2,16,3,0,3,5,1,17,2,1, +144,6,2,16,3,0,3,4,1,17,8,1,136,5,0,12,2,130,53,130,52,130,55,130,54,2,1,17, +3,129,116,131,53,1,2,16,3,0,3,3,1,17,5,1,143,50,41,130,30,130,29,2,16,3,0,3, +2,1,17,4,1,4,44,2,2,16,3,0,3,1,1,17,3,1,136,77,2,2,16,3,0,3,0,1,17,3,1,138,107, +2,2,16,3,0,2,255,1,17,3,1,133,1,2,2,16,3,0,2,254,1,17,2,1,2,2,16,3,0,2,253,1, +17,3,1,138,109,2,2,16,3,0,2,252,2,16,3,0,2,251,1,17,2,1,129,123,2,16,3,0,2,250, +1,17,4,1,129,125,140,12,2,2,16,3,0,2,249,1,17,3,1,133,12,2,2,16,3,0,2,248,1, +17,3,1,140,16,2,2,16,3,0,2,247,1,17,3,1,138,89,129,122,2,16,3,0,2,246,1,17,3, +1,123,2,2,16,3,0,2,245,1,17,3,1,138,59,2,2,16,3,0,2,244,1,17,3,1,138,61,2,2, +16,3,0,2,243,1,17,4,1,133,24,10,2,1,17,2,19,1,2,16,3,0,2,242,1,17,2,1,2,2,16, +3,0,2,241,1,17,3,1,140,31,2,2,16,3,0,2,240,1,17,3,1,140,33,2,2,16,3,0,2,239, +1,17,6,1,143,90,81,130,67,157,29,130,74,2,16,3,0,2,238,1,17,3,1,4,2,2,16,3,0, +2,237,1,17,3,1,133,47,2,2,16,3,0,2,236,1,17,4,1,133,39,2,130,97,2,16,3,0,2,235, +1,17,3,1,90,2,2,16,3,0,2,234,1,17,3,1,136,123,2,2,16,3,0,2,233,1,17,3,1,94,2, +2,16,3,0,2,232,1,17,4,1,56,136,127,2,2,16,3,0,2,231,1,17,3,1,137,1,2,2,16,3, +0,2,230,1,17,3,1,137,3,2,2,16,3,0,2,229,1,17,3,1,139,33,2,2,16,3,0,2,228,1,17, +3,1,139,35,2,2,16,3,0,2,227,1,17,3,1,133,57,2,2,16,3,0,2,226,1,17,3,1,133,59, +2,1,17,2,58,1,1,17,3,57,139,37,1,2,16,3,0,2,225,2,16,3,0,2,224,1,17,4,1,144, +27,2,156,98,2,16,3,0,2,223,1,17,4,1,144,49,2,130,62,1,17,4,2,144,50,1,130,121, +2,16,3,0,2,222,1,17,3,1,130,120,2,2,16,3,0,2,221,1,17,3,129,117,130,60,1,1,17, +3,72,133,72,1,1,17,2,71,1,2,16,3,0,2,220,1,17,4,1,144,69,2,141,44,2,16,3,0,2, +219,1,17,4,1,144,60,2,144,104,2,16,3,0,2,218,1,17,4,1,140,98,2,130,92,2,16,3, +0,2,217,1,17,3,1,130,125,95,2,16,3,0,2,216,1,17,6,1,138,94,2,131,0,22,130,70, +2,16,3,0,2,215,1,17,6,1,138,96,2,131,3,80,130,72,2,16,3,0,2,214,1,17,3,1,127, +130,74,2,16,3,0,2,213,1,17,3,1,138,100,131,9,2,16,3,0,2,212,1,17,7,1,138,102, +6,131,10,144,52,4,2,2,16,3,0,2,211,1,17,5,1,131,8,138,104,2,131,14,2,16,3,0, +2,210,1,17,3,1,139,40,2,1,17,2,130,67,157,6,1,17,4,129,71,138,108,1,131,19,2, +16,3,0,2,209,1,17,4,1,144,65,4,2,2,16,3,0,2,208,1,17,2,1,2,2,16,3,0,2,207,1, +17,4,1,131,17,156,87,24,2,16,3,0,2,206,1,17,4,1,144,71,2,157,11,2,16,3,0,2,205, +1,17,3,1,144,90,2,2,16,3,0,2,204,1,17,3,1,8,2,2,3,11,102,105,108,101,45,119, +114,105,116,101,114,2,3,45,87,97,114,110,105,110,103,58,32,116,101,115,116,99, +97,115,101,32,112,97,100,100,105,110,103,32,115,104,111,117,108,100,32,98,101, +32,37,48,91,48,45,57,93,43,110,2,3,42,87,97,114,110,105,110,103,58,32,117,110, +107,110,111,119,110,32,112,97,116,116,101,114,110,32,105,110,32,111,117,116, +112,117,116,32,112,97,116,104,58,32,39,2,3,21,39,46,32,68,105,100,32,121,111, +117,32,109,101,97,110,32,39,37,110,39,63,2,3,24,69,114,114,111,114,58,32,99, +97,110,110,111,116,32,119,114,105,116,101,32,116,111,32,39,2,3,1,39,2,3,24,32, +99,111,110,110,101,99,116,105,111,110,32,97,116,116,101,109,112,116,115,32,116, +111,32,2,3,1,58,2,3,10,116,99,112,45,115,101,114,118,101,114,2,3,1,45,1,18,2, +136,45,0,0,58,1,17,2,156,93,1,1,24,2,0,0,48,0,13,2,1,24,2,0,0,50,0,13,2,1,24, +2,0,0,52,0,13,2,1,24,4,0,0,49,0,13,2,3,2,1,24,2,0,0,54,0,13,2,1,26,2,0,0,57, +0,13,2,1,25,3,0,0,56,0,13,2,1,1,26,4,0,0,55,0,13,2,3,1,1,24,4,0,0,53,0,13,2, +6,1,1,24,4,0,0,51,0,13,2,6,1,1,18,3,136,54,136,53,1,1,18,2,136,48,1,1,18,3,136, +52,2,1,1,18,3,136,53,1,136,62,1,18,3,136,54,15,1,1,18,2,136,22,1,1,18,2,136, +63,0,0,58,1,17,2,156,111,1,1,18,5,135,127,0,13,1,0,13,1,0,13,0,1,2,3,28,67,111, +117,108,100,110,39,116,32,98,105,110,100,32,116,111,32,108,111,99,97,108,32, +112,111,114,116,32,2,3,14,73,110,118,97,108,105,100,32,112,111,114,116,58,32, +1,24,2,0,0,48,0,13,2,1,24,2,0,0,50,0,13,2,1,24,2,0,0,52,0,13,2,1,24,4,0,0,49, +0,13,2,3,2,1,24,2,0,0,54,0,13,2,1,26,2,0,0,57,0,13,2,1,25,3,0,0,56,0,13,2,1, +1,26,4,0,0,55,0,13,2,3,1,1,24,4,0,0,53,0,13,2,6,1,1,24,4,0,0,51,0,13,2,6,1,1, +18,3,136,75,136,74,1,1,24,2,0,0,48,0,13,2,1,24,2,0,0,50,0,13,2,1,24,2,0,0,52, +0,13,2,1,24,4,0,0,49,0,13,2,3,2,1,24,2,0,0,54,0,13,2,1,26,2,0,0,57,0,13,2,1, +25,3,0,0,56,0,13,2,1,1,26,4,0,0,55,0,13,2,3,1,1,24,4,0,0,53,0,13,2,6,1,1,24, +4,0,0,51,0,13,2,6,1,1,18,3,136,86,136,85,1,1,18,3,136,73,0,0,2,1,1,18,3,136, +84,2,1,1,18,3,136,85,136,24,1,1,18,2,136,69,1,1,18,2,136,94,0,0,58,1,17,2,157, +14,1,1,24,2,0,0,48,0,13,2,1,24,2,0,0,50,0,13,2,1,24,2,0,0,52,0,13,2,1,24,4,0, +0,49,0,13,2,3,2,1,24,2,0,0,54,0,13,2,1,26,2,0,0,57,0,13,2,1,25,3,0,0,56,0,13, +2,1,1,26,4,0,0,55,0,13,2,3,1,1,24,4,0,0,53,0,13,2,6,1,1,24,4,0,0,51,0,13,2,6, +1,1,18,3,136,103,136,102,1,1,18,2,136,97,1,1,18,3,136,101,2,1,1,18,3,136,102, +1,136,111,1,18,3,136,103,15,1,1,18,3,136,98,0,0,3,18,1,18,3,136,105,1,2,1,18, +3,136,96,0,0,2,35,1,18,3,136,107,36,1,1,18,3,136,108,1,3,1,18,2,136,76,1,1,18, +2,136,117,0,0,58,1,17,2,157,37,1,1,18,3,136,69,0,13,1,1,1,18,3,136,70,0,13,1, +136,52,2,3,20,78,111,116,32,97,32,118,97,108,105,100,32,116,97,114,103,101,116, +58,32,1,18,2,136,122,0,0,37,1,17,2,157,42,1,1,18,2,136,124,0,0,48,1,17,2,157, +44,1,1,24,2,0,0,49,0,13,2,1,24,2,0,0,51,0,13,2,1,24,2,0,0,53,0,13,2,1,24,4,0, +0,50,0,13,2,3,2,1,24,2,0,0,55,0,13,2,1,24,2,0,0,57,0,13,2,1,26,4,0,0,56,0,13, +2,2,1,1,24,4,0,0,54,0,13,2,5,1,1,24,4,0,0,52,0,13,2,5,1,1,18,3,137,4,137,3,1, +1,24,2,0,0,48,0,13,2,1,24,2,0,0,50,0,13,2,1,24,2,0,0,52,0,13,2,1,24,4,0,0,49, +0,13,2,3,2,1,24,2,0,0,54,0,13,2,1,26,2,0,0,57,0,13,2,1,25,3,0,0,56,0,13,2,1, +1,26,4,0,0,55,0,13,2,3,1,1,24,4,0,0,53,0,13,2,6,1,1,24,4,0,0,51,0,13,2,6,1,1, +18,3,137,15,137,14,1,1,18,2,137,9,1,1,18,3,137,13,13,1,1,18,3,137,14,24,1,1, +18,2,136,126,1,1,18,2,137,23,0,0,110,1,17,2,157,71,1,1,18,3,137,19,3,151,120, +1,18,3,137,19,1,2,1,18,3,137,20,32,1,1,18,2,136,118,1,2,3,28,82,101,102,117, +115,105,110,103,32,116,111,32,111,118,101,114,119,114,105,116,101,32,102,105, +108,101,32,39,2,3,60,39,32,109,97,110,121,32,116,105,109,101,115,46,32,89,111, +117,32,115,104,111,117,108,100,32,97,100,100,32,37,110,32,111,114,32,37,48,91, +112,97,100,100,105,110,103,93,110,32,116,111,32,116,104,101,32,112,97,116,104, +46,1,4,1,124,1,4,1,117,2,16,3,0,2,203,2,16,3,0,2,202,1,17,4,1,0,12,1,138,27, +2,2,16,3,0,2,201,1,17,4,1,141,111,2,157,75,2,16,3,0,2,200,1,17,3,1,154,2,2,2, +16,3,0,2,199,1,17,3,1,157,104,2,2,16,3,0,2,198,1,17,3,1,138,30,2,2,16,3,0,2, +197,1,17,3,1,131,15,0,12,1,2,16,3,0,2,196,1,17,5,1,145,66,2,158,66,158,78,1, +17,2,131,18,1,2,16,3,0,2,195,1,17,3,1,142,94,132,19,2,16,3,0,2,194,1,17,3,1, +142,93,2,2,16,3,0,2,193,1,17,3,1,142,92,2,2,16,3,0,2,192,1,17,3,1,142,85,2,2, +16,3,0,2,191,1,17,3,1,142,87,2,2,16,3,0,2,190,1,17,3,1,142,9,2,2,16,3,0,2,189, +1,17,2,1,2,2,16,3,0,2,188,1,17,2,1,146,29,2,16,3,0,2,187,1,17,2,1,131,36,2,16, +3,0,2,186,1,17,4,1,145,87,2,132,95,2,16,3,0,2,185,1,17,5,1,145,89,2,158,89,39, +2,16,3,0,2,184,1,17,7,1,138,34,8,0,12,2,129,33,129,32,2,2,16,3,0,2,183,1,17, +3,1,138,99,2,2,16,3,0,2,182,1,17,3,1,141,44,2,2,16,3,0,2,181,2,16,3,0,2,180, +1,17,6,1,138,41,2,0,12,2,129,42,129,41,1,17,2,130,83,146,0,1,17,3,131,69,142, +79,1,2,16,3,0,2,179,1,17,3,1,142,124,2,1,17,3,11,142,87,1,1,17,3,3,146,5,1,2, +16,3,0,2,178,2,16,3,0,2,177,1,17,4,1,146,18,3,2,2,16,3,0,2,176,1,17,3,1,142, +74,2,2,16,3,0,2,175,1,17,3,1,143,5,2,2,16,3,0,2,174,1,17,3,1,142,97,2,2,16,3, +0,2,173,1,17,3,1,139,98,2,2,16,3,0,2,172,1,17,8,1,138,60,21,0,12,2,129,62,145, +121,2,132,122,2,16,3,0,2,171,1,17,3,1,140,58,2,2,16,3,0,2,170,1,17,3,1,142,51, +2,2,16,3,0,2,169,1,17,5,1,141,72,25,42,2,2,16,3,0,2,168,1,17,2,1,139,108,2,16, +3,0,2,167,1,17,6,1,140,66,4,146,3,2,133,4,2,16,3,0,2,166,1,17,3,1,140,68,2,2, +16,3,0,2,165,1,17,3,1,158,47,2,2,16,3,0,2,164,1,17,4,1,141,113,38,2,2,16,3,0, +2,163,1,17,3,1,131,86,2,1,17,2,132,35,141,85,2,16,3,0,2,162,1,17,2,1,139,121, +2,16,3,0,2,161,1,17,2,1,2,2,16,3,0,2,160,1,17,4,1,140,110,6,2,2,16,3,0,2,159, +2,16,3,0,2,158,1,17,3,1,143,42,2,2,16,3,0,2,157,1,17,6,1,138,90,0,12,2,129,87, +129,86,2,2,16,3,0,2,156,1,17,3,1,143,34,2,2,16,3,0,2,155,1,17,4,1,145,62,2,0, +0,131,255,127,1,17,2,68,131,103,1,17,4,67,146,25,1,159,33,2,16,3,0,2,154,1,17, +4,1,146,27,2,133,33,2,16,3,0,2,153,1,17,8,1,146,85,6,0,12,131,255,127,146,29, +2,159,29,159,1,2,16,3,0,2,152,1,17,3,1,139,31,2,2,16,3,0,2,151,1,17,2,1,2,2, +16,3,0,2,150,1,17,3,1,131,114,2,2,16,3,0,2,149,1,17,3,1,23,2,2,16,3,0,2,148, +1,17,2,1,24,2,16,3,0,2,147,1,17,3,1,158,85,2,1,17,2,131,121,1,2,16,3,0,2,146, +1,17,4,1,146,44,131,20,133,50,1,17,3,130,82,31,1,2,16,3,0,2,145,1,17,5,1,146, +47,2,159,47,124,2,16,3,0,2,144,1,17,2,1,2,2,16,3,0,2,143,1,17,3,1,9,2,1,17,2, +156,73,1,1,17,2,132,4,1,1,17,2,132,81,159,20,2,16,3,0,2,142,1,17,7,1,49,139, +6,151,89,0,12,2,129,8,129,7,2,16,3,0,2,141,1,17,4,1,129,11,4,2,2,16,3,0,2,140, +1,17,3,1,143,72,0,0,132,128,0,2,16,3,0,2,139,1,17,3,1,150,66,2,1,17,3,130,31, +143,75,0,0,130,0,1,17,2,131,48,27,2,16,3,0,2,138,1,17,7,1,139,16,151,99,0,12, +2,129,54,141,67,2,2,16,3,0,2,137,1,17,5,1,146,87,6,5,2,2,16,3,0,2,136,1,17,4, +1,146,89,2,150,74,2,16,3,0,2,135,1,17,2,1,137,26,2,16,3,0,2,134,1,17,4,1,146, +113,4,2,2,16,3,0,2,133,1,17,3,1,129,65,2,2,16,3,0,2,132,1,17,3,1,137,32,2,2, +16,3,0,2,131,1,17,3,1,158,121,2,1,17,5,133,10,143,92,23,129,71,1,2,16,3,0,2, +130,1,17,5,1,139,28,151,116,129,126,30,2,16,3,0,2,129,1,17,7,1,139,35,151,118, +0,12,2,129,127,139,42,2,2,16,3,0,2,128,1,17,4,1,143,99,0,0,132,128,0,2,2,16, +3,0,2,127,1,17,3,1,150,93,2,2,16,3,0,2,126,1,17,3,1,137,45,2,2,16,3,0,2,125, +1,17,5,1,129,86,12,130,9,2,2,16,3,0,2,124,1,17,4,1,130,14,2,129,28,2,16,3,0, +2,123,1,17,4,1,141,36,2,130,34,2,3,8,111,110,99,101,45,100,101,99,2,3,8,109, +97,110,121,45,100,101,99,2,3,5,98,117,114,115,116,2,3,2,111,100,2,3,11,77,117, +116,97,116,101,32,111,110,99,101,2,3,2,110,100,2,3,26,77,117,116,97,116,101, +32,112,111,115,115,105,98,108,121,32,109,97,110,121,32,116,105,109,101,115,2, +3,2,98,117,2,3,35,77,97,107,101,32,115,101,118,101,114,97,108,32,109,117,116, +97,116,105,111,110,115,32,99,108,111,115,101,98,121,32,111,110,99,101,2,3,8, +111,100,44,110,100,44,98,117,2,3,17,85,110,107,110,111,119,110,32,112,97,116, +116,101,114,110,58,32,1,18,2,138,90,0,0,61,1,17,2,159,10,1,1,18,3,138,42,0,13, +1,1,1,18,2,138,93,0,0,44,1,17,2,159,13,1,1,18,3,138,45,0,13,1,1,1,4,1,17,1,4, +1,17,1,4,1,17,2,16,3,0,2,122,2,16,3,0,2,121,2,16,3,0,2,120,1,17,3,1,144,18,2, +2,16,3,0,2,119,2,16,3,0,2,118,1,17,3,1,3,2,2,16,3,0,2,117,1,17,4,1,159,41,8, +2,2,16,3,0,2,116,1,17,4,1,136,56,2,132,1,2,16,3,0,2,115,1,17,3,1,141,80,2,2, +16,3,0,2,114,1,17,2,1,2,2,16,3,0,2,113,1,17,3,1,143,64,2,2,16,3,0,2,112,1,17, +3,1,136,64,2,2,16,3,0,2,111,1,17,2,1,143,58,2,16,3,0,2,110,1,17,3,1,4,2,2,16, +3,0,2,109,1,17,5,1,147,14,2,160,117,27,2,16,3,0,2,108,2,16,3,0,2,107,1,17,2, +1,143,65,2,16,3,0,2,106,1,17,4,1,136,25,2,133,108,2,16,3,0,2,105,1,17,3,1,13, +2,2,16,3,0,2,104,1,17,5,1,147,23,2,160,126,35,1,17,2,9,1,2,16,3,0,2,103,2,16, +3,0,2,102,1,17,3,1,144,52,2,2,16,3,0,2,101,1,17,3,1,143,77,2,2,16,3,0,2,100, +1,17,4,1,144,43,41,2,2,16,3,0,2,99,1,17,4,1,136,39,2,133,122,2,16,3,0,2,98,1, +17,2,1,2,1,17,3,25,28,1,1,17,5,24,147,37,1,161,12,48,1,2,3,65,24,64,1,2,3,64, +15,63,1,2,3,63,3,62,1,1,2,1,0,13,0,1,1,2,3,1,1,1,2,5,1,2,16,3,0,2,97,1,17,5, +1,139,116,152,78,0,12,2,65,2,16,3,0,2,96,1,17,4,1,133,118,2,4,2,16,3,0,2,95, +2,16,3,0,2,94,1,17,3,1,133,95,2,2,16,3,0,2,93,1,17,3,1,136,108,2,2,16,3,0,2, +92,1,17,2,1,2,1,17,4,131,37,147,105,1,144,80,1,17,4,131,36,147,95,1,148,11,1, +17,4,131,35,144,4,1,133,126,2,16,3,0,2,91,1,17,2,1,2,2,16,3,0,2,90,1,17,4,1, +147,80,2,160,23,1,17,4,131,53,147,101,1,15,1,17,4,131,54,147,102,1,133,115,1, +17,4,131,55,147,103,1,81,1,17,3,131,53,79,1,1,42,2,0,0,11,0,0,20,2,3,8,109,117, +116,97,45,110,117,109,2,3,9,98,121,116,101,45,100,114,111,112,2,3,8,98,121,116, +101,45,105,110,99,2,3,8,98,121,116,101,45,100,101,99,2,3,11,98,121,116,101,45, +105,110,115,101,114,116,2,3,11,98,121,116,101,45,114,101,112,101,97,116,2,3, +11,98,121,116,101,45,114,97,110,100,111,109,2,3,9,98,121,116,101,45,112,101, +114,109,2,3,9,102,117,115,101,45,116,104,105,115,2,3,9,102,117,115,101,45,110, +101,120,116,2,3,8,102,117,115,101,45,111,108,100,2,3,10,115,101,113,45,114,101, +112,101,97,116,2,3,11,115,101,100,45,115,101,113,45,100,101,108,2,3,8,108,105, +110,101,45,100,101,108,2,3,12,108,105,110,101,45,100,101,108,45,115,101,113, +2,3,8,108,105,110,101,45,100,117,112,2,3,10,108,105,110,101,45,99,108,111,110, +101,2,3,11,108,105,110,101,45,114,101,112,101,97,116,2,3,9,108,105,110,101,45, +115,119,97,112,2,3,9,108,105,110,101,45,112,101,114,109,2,3,8,108,105,115,116, +45,105,110,115,2,3,12,108,105,115,116,45,114,101,112,108,97,99,101,2,3,10,117, +116,102,56,45,119,105,100,101,110,2,3,11,117,116,102,56,45,105,110,115,101,114, +116,2,3,13,116,114,101,101,45,115,119,97,112,45,111,110,101,2,3,13,116,114,101, +101,45,115,119,97,112,45,116,119,111,2,3,8,116,114,101,101,45,100,101,108,2, +3,8,116,114,101,101,45,100,117,112,2,3,12,116,114,101,101,45,115,116,117,116, +116,101,114,2,3,4,98,121,116,101,2,3,4,116,101,120,116,2,3,9,100,101,108,105, +109,105,116,101,100,2,3,37,115,116,114,105,110,103,45,102,108,97,116,116,101, +110,58,32,119,104,97,116,32,107,105,110,100,32,111,102,32,110,111,100,101,32, +105,115,32,2,3,23,115,116,114,105,110,103,45,109,117,116,97,116,101,58,32,119, +104,97,116,32,105,115,32,2,3,9,97,98,45,115,116,114,105,110,103,2,3,2,97,98, +2,3,50,101,110,104,97,110,99,101,32,115,105,108,108,121,32,105,115,115,117,101, +115,32,105,110,32,65,83,67,73,73,32,115,116,114,105,110,103,32,100,97,116,97, +32,104,97,110,100,108,105,110,103,2,3,2,98,100,2,3,11,100,114,111,112,32,97, +32,98,121,116,101,2,3,2,98,102,2,3,12,102,108,105,112,32,111,110,101,32,98,105, +116,2,3,2,98,105,2,3,20,105,110,115,101,114,116,32,97,32,114,97,110,100,111, +109,32,98,121,116,101,2,3,2,98,114,2,3,13,114,101,112,101,97,116,32,97,32,98, +121,116,101,2,3,2,98,112,2,3,18,112,101,114,109,117,116,101,32,115,111,109,101, +32,98,121,116,101,115,2,3,3,98,101,105,2,3,23,105,110,99,114,101,109,101,110, +116,32,97,32,98,121,116,101,32,98,121,32,111,110,101,2,3,3,98,101,100,2,3,23, +100,101,99,114,101,109,101,110,116,32,97,32,98,121,116,101,32,98,121,32,111, +110,101,2,3,3,98,101,114,2,3,29,115,119,97,112,32,97,32,98,121,116,101,32,119, +105,116,104,32,97,32,114,97,110,100,111,109,32,111,110,101,2,3,2,115,114,2,3, +26,114,101,112,101,97,116,32,97,32,115,101,113,117,101,110,99,101,32,111,102, +32,98,121,116,101,115,2,3,2,115,100,2,3,26,100,101,108,101,116,101,32,97,32, +115,101,113,117,101,110,99,101,32,111,102,32,98,121,116,101,115,2,3,2,108,100, +2,3,13,100,101,108,101,116,101,32,97,32,108,105,110,101,2,3,3,108,100,115,2, +3,17,100,101,108,101,116,101,32,109,97,110,121,32,108,105,110,101,115,2,3,3, +108,114,50,2,3,16,100,117,112,108,105,99,97,116,101,32,97,32,108,105,110,101, +2,3,2,108,105,2,3,19,99,111,112,121,32,97,32,108,105,110,101,32,99,108,111,115, +101,98,121,2,3,2,108,114,2,3,13,114,101,112,101,97,116,32,97,32,108,105,110, +101,2,3,2,108,115,2,3,14,115,119,97,112,32,116,119,111,32,108,105,110,101,115, +2,3,2,108,112,2,3,19,115,119,97,112,32,111,114,100,101,114,32,111,102,32,108, +105,110,101,115,2,3,3,108,105,115,2,3,28,105,110,115,101,114,116,32,97,32,108, +105,110,101,32,102,114,111,109,32,101,108,115,101,119,104,101,114,101,2,3,3, +108,114,115,2,3,38,114,101,112,108,97,99,101,32,97,32,108,105,110,101,32,119, +105,116,104,32,111,110,101,32,102,114,111,109,32,101,108,115,101,119,104,101, +114,101,2,3,2,116,100,2,3,13,100,101,108,101,116,101,32,97,32,110,111,100,101, +2,3,3,116,114,50,2,3,16,100,117,112,108,105,99,97,116,101,32,97,32,110,111,100, +101,2,3,3,116,115,49,2,3,30,115,119,97,112,32,111,110,101,32,110,111,100,101, +32,119,105,116,104,32,97,110,111,116,104,101,114,32,111,110,101,2,3,3,116,115, +50,2,3,23,115,119,97,112,32,116,119,111,32,110,111,100,101,115,32,112,97,105, +114,119,105,115,101,2,3,2,116,114,2,3,31,114,101,112,101,97,116,32,97,32,112, +97,116,104,32,111,102,32,116,104,101,32,112,97,114,115,101,32,116,114,101,101, +2,3,2,117,119,2,3,33,116,114,121,32,116,111,32,109,97,107,101,32,97,32,99,111, +100,101,32,112,111,105,110,116,32,116,111,111,32,119,105,100,101,2,3,2,117,105, +2,3,20,105,110,115,101,114,116,32,102,117,110,110,121,32,117,110,105,99,111, +100,101,2,3,3,110,117,109,2,3,30,116,114,121,32,116,111,32,109,111,100,105,102, +121,32,97,32,116,101,120,116,117,97,108,32,110,117,109,98,101,114,2,3,2,120, +112,2,3,30,116,114,121,32,116,111,32,112,97,114,115,101,32,88,77,76,32,97,110, +100,32,109,117,116,97,116,101,32,105,116,2,3,2,102,116,2,3,35,106,117,109,112, +32,116,111,32,97,32,115,105,109,105,108,97,114,32,112,111,115,105,116,105,111, +110,32,105,110,32,98,108,111,99,107,2,3,2,102,110,2,3,43,108,105,107,101,108, +121,32,99,108,111,110,101,32,100,97,116,97,32,98,101,116,119,101,101,110,32, +115,105,109,105,108,97,114,32,112,111,115,105,116,105,111,110,115,2,3,2,102, +111,2,3,35,102,117,115,101,32,112,114,101,118,105,111,117,115,108,121,32,115, +101,101,110,32,100,97,116,97,32,101,108,115,101,119,104,101,114,101,2,3,116, +102,116,61,50,44,102,111,61,50,44,102,110,44,110,117,109,61,53,44,116,100,44, +116,114,50,44,116,115,49,44,116,114,44,116,115,50,44,108,100,44,108,100,115, +44,108,114,50,44,108,105,44,108,115,44,108,112,44,108,114,44,108,105,115,44, +108,114,115,44,115,114,44,115,100,44,98,100,44,98,102,44,98,105,44,98,114,44, +98,112,44,98,101,105,44,98,101,100,44,98,101,114,44,117,119,44,117,105,61,50, +44,120,112,61,57,44,97,98,2,3,18,85,110,107,110,111,119,110,32,109,117,116,97, +116,105,111,110,58,32,1,18,2,140,21,0,0,61,1,17,2,160,69,1,1,18,3,139,101,0, +13,1,1,1,18,2,140,24,0,0,44,1,17,2,160,72,1,1,18,3,139,104,0,13,1,1,1,4,1,107, +1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1, +107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1, +4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107, +1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1,107,1,4,1, +107,1,4,1,105,2,16,3,0,2,89,1,17,2,1,134,123,1,17,2,134,36,1,1,17,3,134,56,145, +74,134,57,1,17,3,134,52,138,11,1,2,16,3,0,2,88,1,17,3,1,145,69,2,1,17,3,133, +84,148,115,134,61,2,16,3,0,2,87,1,17,3,1,145,67,2,2,16,3,0,2,86,1,17,3,1,145, +53,2,1,17,3,132,103,138,19,1,2,16,3,0,2,85,1,17,3,1,145,115,2,2,16,3,0,2,84, +1,17,3,1,138,23,2,2,16,3,0,2,83,1,17,3,1,145,110,2,2,16,3,0,2,82,1,17,3,1,145, +83,2,2,16,3,0,2,81,2,16,3,0,2,80,1,17,4,1,21,134,77,2,1,17,3,134,72,138,31,1, +1,17,3,20,145,88,1,2,16,3,0,2,79,2,16,3,0,2,78,1,17,3,1,146,1,2,1,17,2,134,63, +1,2,16,3,0,2,77,1,17,2,1,2,2,16,3,0,2,76,1,17,4,1,31,134,87,2,2,16,3,0,2,75, +1,17,3,1,145,120,2,2,16,3,0,2,74,1,17,3,1,138,15,2,1,17,3,134,86,138,45,1,1, +17,3,34,145,102,1,2,16,3,0,2,73,1,17,3,1,145,106,134,95,1,17,3,132,123,145,119, +1,1,17,3,132,122,138,50,1,2,16,3,0,2,72,1,17,3,1,138,52,2,1,17,3,41,145,109, +1,2,16,3,0,2,71,2,16,3,0,2,70,1,17,3,1,161,39,2,1,17,3,135,54,161,42,1,1,17, +4,29,49,134,105,1,1,17,3,134,100,138,59,1,2,16,3,0,2,69,1,17,3,1,146,27,2,2, +16,3,0,2,68,1,17,3,1,146,19,2,1,17,3,38,145,120,1,1,17,3,134,7,149,38,134,112, +1,17,3,133,22,149,39,1,2,16,3,0,2,67,1,17,3,1,145,119,2,1,17,3,133,29,138,25, +1,2,16,3,0,2,66,1,17,3,1,145,124,2,2,16,3,0,2,65,1,17,3,1,145,124,2,2,16,3,0, +2,64,1,17,3,1,146,0,2,2,16,3,0,2,63,1,17,3,1,146,27,2,2,16,3,0,2,62,1,17,3,1, +146,30,2,2,16,3,0,2,61,1,17,3,1,138,52,2,2,16,3,0,2,60,1,17,3,1,138,50,2,1,17, +3,64,146,50,1,1,17,3,133,41,138,85,1,2,16,3,0,2,59,1,17,3,1,146,53,2,2,16,3, +0,2,58,1,17,3,1,146,45,2,1,17,3,64,146,18,1,2,16,3,0,2,57,2,16,3,0,2,56,1,17, +3,1,146,35,2,2,16,3,0,2,55,1,17,4,1,86,135,14,2,2,16,3,0,2,54,1,17,3,1,146,66, +2,2,16,3,0,2,53,1,17,3,1,146,41,2,2,16,3,0,2,52,1,17,3,1,138,101,2,2,16,3,0, +2,51,1,17,3,1,146,59,2,2,16,3,0,2,50,2,16,3,0,2,49,1,17,3,1,146,48,2,2,16,3, +0,2,48,1,17,3,1,146,77,2,2,16,3,0,2,47,1,17,4,1,138,110,7,2,2,16,3,0,2,46,1, +17,3,1,146,68,2,1,17,2,130,42,1,2,16,3,0,2,45,1,17,3,1,146,57,135,34,2,16,3, +0,2,44,1,17,3,1,138,117,2,2,16,3,0,2,43,2,16,3,0,2,42,1,17,4,1,111,134,40,2, +2,16,3,0,2,41,1,17,3,1,138,122,2,2,16,3,0,2,40,1,17,3,1,7,2,2,16,3,0,2,39,1, +17,3,1,13,2,2,16,3,0,2,38,1,17,3,1,146,56,2,2,16,3,0,2,37,1,17,4,11,121,134, +50,1,1,17,3,10,139,3,1,1,17,3,9,15,1,1,17,3,8,20,1,1,17,3,7,146,62,1,2,3,4,111, +112,101,110,2,3,11,111,112,101,110,45,115,105,110,103,108,101,2,3,3,98,117,103, +2,3,36,98,117,103,32,45,32,101,118,101,114,121,116,104,105,110,103,32,115,104, +111,117,108,100,32,98,101,32,112,97,114,115,101,97,98,108,101,2,3,16,119,104, +97,116,32,102,105,110,101,32,110,111,100,101,58,32,2,3,16,119,104,97,116,32, +102,105,110,101,32,110,111,100,101,58,32,1,24,2,0,0,48,0,13,2,1,24,2,0,0,50, +0,13,2,1,24,2,0,0,52,0,13,2,1,24,4,0,0,49,0,13,2,3,2,1,24,2,0,0,54,0,13,2,1, +26,2,0,0,57,0,13,2,1,25,3,0,0,56,0,13,2,1,1,26,4,0,0,55,0,13,2,3,1,1,24,4,0, +0,53,0,13,2,6,1,1,24,4,0,0,51,0,13,2,6,1,1,18,3,141,73,141,72,1,1,18,2,141,67, +1,1,18,3,141,71,2,1,1,18,3,141,72,1,141,81,1,18,2,141,40,1,2,3,19,116,97,103, +45,105,110,102,111,58,32,98,97,100,32,110,111,100,101,32,2,3,7,87,84,78,32,73, +83,32,2,3,3,63,63,63,2,3,7,87,84,78,32,73,83,32,2,3,3,63,63,63,2,3,7,120,112, +45,115,119,97,112,2,3,36,103,101,110,101,114,97,116,101,45,110,111,100,101,58, +32,117,110,101,120,112,101,99,116,101,100,32,110,111,100,101,32,116,121,112, +101,32,2,3,9,120,112,45,105,110,115,101,114,116,2,3,6,120,112,45,100,117,112, +2,3,7,120,112,45,112,117,109,112,2,3,9,120,112,45,114,101,112,101,97,116,1,4, +1,32,1,4,1,32,1,4,1,8,1,4,1,7,1,4,1,7,1,4,1,7,1,4,1,7,2,16,3,0,2,36,2,16,3,0, +2,35,1,17,3,1,162,36,2,2,16,3,0,2,34,1,17,3,1,150,36,2,1,18,2,142,33,0,0,32, +1,18,2,142,34,0,0,10,1,18,3,142,31,2,1,1,18,3,142,27,1,0,13,2,1,18,2,142,37, +0,0,34,1,18,2,142,38,0,0,39,1,18,3,142,35,2,1,2,16,3,0,2,33,1,17,2,1,147,15, +2,16,3,0,2,32,1,17,4,1,147,16,2,147,17,2,16,3,0,2,31,1,17,4,1,147,18,2,147,19, +2,16,3,0,2,30,1,17,3,1,147,20,2,1,18,2,142,51,1,1,18,3,142,40,1,0,13,1,2,16, +3,0,2,29,2,16,3,0,2,28,1,17,3,1,150,43,2,2,16,3,0,2,27,1,17,2,1,2,2,16,3,0,2, +26,1,17,3,1,142,55,2,2,16,3,0,2,25,1,17,2,1,2,2,16,3,0,2,24,1,17,3,1,142,49, +2,2,16,3,0,2,23,2,16,3,0,2,22,1,17,3,1,142,70,2,2,16,3,0,2,21,1,17,2,1,2,2,16, +3,0,2,20,1,17,3,1,142,66,2,2,16,3,0,2,19,1,17,4,1,142,64,9,2,2,16,3,0,2,18,1, +17,2,1,162,127,2,16,3,0,2,17,1,17,4,1,142,75,4,2,1,17,2,160,59,1,2,16,3,0,2, +16,2,16,3,0,2,15,1,17,2,1,2,2,16,3,0,2,14,1,17,3,1,5,2,2,16,3,0,2,13,1,17,3, +1,42,2,1,18,3,142,78,1,33,2,16,3,0,2,12,2,16,3,0,2,11,1,17,3,1,53,2,1,17,2,29, +1,1,17,3,25,5,157,28,2,16,3,0,2,10,1,17,3,1,53,2,1,17,2,26,1,2,16,3,0,2,9,1, +17,3,1,142,91,2,1,17,4,25,142,88,7,1,2,16,3,0,2,8,1,17,3,1,142,101,2,2,16,3, +0,2,7,1,17,3,1,61,2,1,17,3,10,49,1,1,17,3,19,63,1,2,16,3,0,2,6,2,16,3,0,2,5, +1,17,2,1,2,2,16,3,0,2,4,1,17,2,1,83,1,17,2,41,1,2,16,3,0,2,3,1,17,3,1,142,106, +2,1,17,2,5,86,1,17,2,45,1,2,16,3,0,2,2,1,17,3,1,142,110,2,1,17,2,48,1,2,16,3, +0,2,1,1,17,3,1,142,113,2,2,16,3,0,2,0,1,17,5,1,142,111,14,9,2,2,16,3,0,1,255, +1,17,3,1,82,2,1,17,2,62,1,2,16,3,0,1,254,1,17,4,1,142,110,2,22,1,17,3,42,73, +1,2,16,3,0,1,253,1,17,2,1,157,65,2,16,3,0,1,252,1,17,2,1,137,95,1,17,2,70,1, +2,16,3,0,1,251,1,17,3,1,143,0,2,1,17,3,34,94,1,1,17,3,43,82,1,1,17,2,68,1,1, +17,3,20,143,4,1,2,16,3,0,1,250,1,17,5,1,143,2,11,2,13,1,17,2,72,1,2,16,3,0,1, +249,1,17,3,1,143,9,2,2,16,3,0,1,248,2,16,3,0,1,247,1,17,2,1,137,71,1,17,2,78, +1,2,16,3,0,1,246,1,17,3,1,143,5,2,2,16,3,0,1,245,1,17,4,1,143,20,2,7,2,16,3, +0,1,244,1,17,2,1,137,78,2,16,3,0,1,243,1,17,3,1,2,100,1,17,3,55,5,1,1,17,3,72, +143,31,1,1,18,3,143,21,15,1,1,18,3,143,17,1,0,13,2,2,16,3,0,1,242,1,17,5,1,142, +105,2,129,37,129,36,2,16,3,0,1,241,2,16,3,0,1,240,1,17,4,1,0,13,3,150,125,2, +1,17,2,137,73,1,1,17,2,137,80,150,123,2,16,3,0,1,239,1,17,2,1,2,2,16,3,0,1,238, +1,17,5,1,150,127,151,3,2,0,13,3,2,16,3,0,1,237,1,17,2,1,2,2,16,3,0,1,236,2,16, +3,0,1,235,1,17,3,1,3,2,2,16,3,0,1,234,1,17,3,1,12,2,2,16,3,0,1,233,2,16,3,0, +1,232,1,17,2,1,2,2,16,3,0,1,231,1,17,2,1,2,1,17,2,136,95,1,2,16,3,0,1,230,1, +17,3,1,151,77,0,0,127,2,16,3,0,1,229,1,17,2,1,129,33,2,16,3,0,1,228,2,16,3,0, +1,227,1,17,3,1,13,2,2,16,3,0,1,226,1,17,4,1,9,5,2,1,17,2,7,129,38,1,17,3,5,17, +6,1,17,4,4,12,2,1,2,16,3,0,1,225,1,17,2,1,138,33,1,17,3,14,151,90,0,0,127,2, +16,3,0,1,224,1,17,14,1,143,102,15,129,73,137,125,129,46,23,8,129,45,5,138,36, +3,2,129,74,2,16,3,0,1,223,1,17,2,1,24,2,16,3,0,1,222,1,17,4,1,159,105,4,2,2, +16,3,0,1,221,1,17,3,1,163,79,2,1,17,2,137,115,1,2,16,3,0,1,220,1,17,2,1,138, +6,2,16,3,0,1,219,1,17,4,1,138,8,151,69,2,2,16,3,0,1,218,1,17,3,1,151,84,2,2, +16,3,0,1,217,1,17,2,1,129,61,2,16,3,0,1,216,1,17,2,1,2,2,16,3,0,1,215,1,17,2, +1,154,78,2,16,3,0,1,214,1,17,7,1,151,77,138,18,129,67,138,57,4,2,1,17,2,138, +2,1,2,16,3,0,1,213,1,17,2,1,2,2,16,3,0,1,212,1,17,3,1,151,55,0,13,3,2,16,3,0, +1,211,1,17,3,1,151,61,2,2,16,3,0,1,210,1,17,2,1,129,88,2,16,3,0,1,209,2,16,3, +0,1,208,1,17,3,1,148,87,2,2,16,3,0,1,207,1,17,3,1,149,102,2,2,16,3,0,1,206,1, +17,2,1,2,2,16,3,0,1,205,1,17,3,1,2,137,43,2,16,3,0,1,204,1,17,3,1,137,26,2,1, +17,2,161,94,1,1,17,2,137,19,151,74,1,17,2,137,100,2,1,17,3,132,112,142,28,1, +1,17,2,138,32,151,75,2,16,3,0,1,203,1,17,4,1,147,26,3,2,2,16,3,0,1,202,1,17, +3,1,20,2,2,16,3,0,1,201,1,17,4,1,152,3,9,2,2,16,3,0,1,200,1,17,3,1,151,87,2, +2,16,3,0,1,199,1,17,3,1,28,2,2,16,3,0,1,198,1,17,2,1,2,2,16,3,0,1,197,1,17,13, +1,138,57,129,106,4,138,96,129,105,154,119,152,11,2,138,40,144,39,0,12,2,129, +117,2,16,3,0,1,196,1,17,4,1,152,13,138,42,2,2,16,3,0,1,195,2,16,3,0,1,194,1, +17,3,1,3,2,2,16,3,0,1,193,1,17,3,1,43,2,1,17,3,137,66,61,1,1,17,3,134,4,56,1, +2,16,3,0,1,192,1,17,3,1,110,2,2,16,3,0,1,191,2,16,3,0,1,190,2,16,3,0,1,189,1, +17,3,1,152,5,2,2,16,3,0,1,188,1,17,4,1,152,7,5,2,2,16,3,0,1,187,1,17,2,1,2,1, +17,2,138,60,1,2,16,3,0,1,186,1,17,3,8,152,12,1,2,16,3,0,1,185,1,17,3,1,4,2,1, +17,3,11,152,15,4,2,16,3,0,1,184,1,17,3,1,7,2,2,16,3,0,1,183,2,16,3,0,1,182,1, +17,3,1,152,20,2,2,16,3,0,1,181,1,17,2,1,152,56,1,17,2,138,79,9,2,16,3,0,1,180, +1,17,2,1,2,1,17,3,112,152,60,0,0,127,2,16,3,0,1,179,1,17,21,1,144,70,6,0,12, +2,130,24,130,23,138,95,152,28,155,29,8,3,130,16,14,130,15,11,139,6,164,95,138, +77,2,130,26,130,25,2,16,3,0,1,178,1,17,5,1,160,73,2,152,43,138,80,2,16,3,0,1, +177,1,17,3,1,152,57,2,2,16,3,0,1,176,1,17,2,1,2,2,16,3,0,1,175,1,17,3,1,152, +57,138,86,2,16,3,0,1,174,1,17,6,1,164,105,138,53,155,39,152,59,138,88,2,16,3, +0,1,173,1,17,2,1,2,2,16,3,0,1,172,1,17,2,1,2,2,16,3,0,1,171,1,17,4,1,164,59, +8,2,2,16,3,0,1,170,1,17,4,1,130,33,155,47,130,34,1,18,2,3,1,2,16,3,0,1,169,1, +17,2,1,155,50,1,18,2,6,1,1,18,2,7,164,112,2,16,3,0,1,168,1,17,3,1,155,54,138, +120,1,18,2,10,1,2,16,3,0,1,167,1,17,3,1,152,66,137,106,2,16,3,0,1,166,1,17,2, +1,155,59,2,16,3,0,1,165,1,17,5,1,155,61,152,70,2,137,110,2,16,3,0,1,164,1,17, +2,1,2,2,16,3,0,1,163,1,17,4,1,164,79,8,2,2,16,3,0,1,162,2,16,3,0,1,161,1,17, +4,1,3,137,14,2,2,16,3,0,1,160,1,17,3,1,141,52,2,2,16,3,0,1,159,1,17,4,1,164, +85,133,52,2,2,16,3,0,1,158,1,17,3,1,164,87,2,2,16,3,0,1,157,1,17,3,1,28,2,1, +17,2,134,38,141,94,2,16,3,0,1,156,1,17,3,1,152,17,2,2,16,3,0,1,155,2,16,3,0, +1,154,2,16,3,0,1,153,1,17,2,1,2,2,16,3,0,1,152,1,17,3,1,147,5,2,2,16,3,0,1,151, +1,17,3,1,141,113,2,2,16,3,0,1,150,1,17,4,1,152,43,9,2,2,16,3,0,1,149,1,17,8, +1,165,29,130,78,130,77,155,91,153,1,130,83,138,36,2,16,3,0,1,148,1,17,3,1,4, +2,2,16,3,0,1,147,1,17,3,1,152,69,2,2,16,3,0,1,146,1,17,3,1,18,2,2,16,3,0,1,145, +2,16,3,0,1,144,1,17,4,1,35,137,46,2,2,16,3,0,1,143,1,17,3,1,5,2,1,17,3,136,85, +141,120,1,2,16,3,0,1,142,1,17,3,1,53,2,1,17,3,31,51,1,2,16,3,0,1,141,1,17,2, +1,165,46,2,16,3,0,1,140,1,17,4,1,45,137,56,2,2,16,3,0,1,139,1,17,3,1,142,1,2, +1,17,3,38,65,1,2,16,3,0,1,138,1,17,3,1,149,110,138,60,2,16,3,0,1,137,1,17,5, +1,152,6,139,37,142,15,2,2,16,3,0,1,136,1,17,3,1,0,0,129,128,0,2,2,16,3,0,1,135, +1,17,3,1,149,21,2,2,16,3,0,1,134,1,17,2,1,2,2,16,3,0,1,133,2,16,3,0,1,132,1, +17,3,1,149,26,2,2,16,3,0,1,131,1,17,2,1,2,2,16,3,0,1,130,1,17,4,1,65,139,50, +32,2,16,3,0,1,129,1,17,6,1,67,137,78,34,149,124,2,2,16,3,0,1,128,1,17,2,1,2, +2,16,3,0,1,127,1,17,3,1,13,2,2,16,3,0,1,126,1,17,3,1,142,27,2,1,17,2,130,77, +165,75,2,16,3,0,1,125,1,17,4,1,153,5,3,2,2,16,3,0,1,124,1,17,3,1,88,2,2,16,3, +0,1,123,1,17,3,1,17,2,2,16,3,0,1,122,1,17,4,135,11,149,64,2,1,2,16,3,0,1,121, +1,17,3,1,98,2,2,16,3,0,1,120,1,17,4,1,150,15,139,71,165,89,2,16,3,0,1,119,1, +17,3,1,138,98,2,1,17,3,137,110,31,1,1,17,4,56,90,137,101,57,2,16,3,0,1,118,1, +17,3,1,3,2,1,17,3,47,142,47,1,1,17,3,84,111,1,2,16,3,0,1,117,1,17,11,1,85,131, +18,48,131,16,12,131,15,2,131,14,55,131,17,2,16,3,0,1,116,1,17,3,1,142,61,2,2, +16,3,0,1,115,2,16,3,0,1,114,1,17,2,1,2,2,16,3,0,1,113,1,17,3,1,5,2,1,17,2,138, +94,1,2,16,3,0,1,112,2,16,3,0,1,111,1,17,2,1,0,32,1,2,16,3,0,1,110,2,16,3,0,1, +109,1,17,3,1,139,97,2,2,16,3,0,1,108,1,17,3,1,139,47,2,2,16,3,0,1,107,1,17,2, +1,2,2,16,3,0,1,106,1,17,3,1,129,18,2,2,16,3,0,1,105,1,17,4,1,11,14,2,2,16,3, +0,1,104,1,17,3,1,15,2,2,16,3,0,1,103,1,17,3,1,129,57,2,2,16,3,0,1,102,1,17,3, +1,147,126,2,2,16,3,0,1,101,1,17,2,1,2,1,18,4,3,0,13,3,0,13,3,1,2,16,3,0,1,100, +1,17,2,1,0,32,1,2,16,3,0,1,99,1,17,3,1,149,96,2,2,16,3,0,1,98,1,17,2,1,0,32, +1,1,17,4,138,71,142,47,1,133,103,2,16,3,0,1,97,1,17,4,1,150,68,139,121,0,0,129, +0,1,17,2,135,92,1,2,16,3,0,1,96,1,17,2,139,73,162,40,2,16,3,0,1,95,1,17,4,1, +2,139,126,162,42,2,16,3,0,1,94,1,17,4,1,150,72,5,2,2,16,3,0,1,93,1,17,2,1,150, +74,2,16,3,0,1,92,1,17,3,1,150,79,138,107,1,17,3,137,71,150,80,1,2,16,3,0,1,91, +1,17,3,1,150,76,2,2,16,3,0,1,90,1,17,3,1,7,2,2,16,3,0,1,89,1,17,2,1,2,1,17,2, +139,16,139,105,1,17,2,139,18,1,2,16,3,0,1,88,2,16,3,0,1,87,1,17,2,1,0,32,1,2, +16,3,0,1,86,1,17,3,1,147,51,2,2,16,3,0,1,85,1,17,3,1,147,53,2,2,16,3,0,1,84, +1,17,3,1,9,138,48,2,16,3,0,1,83,1,17,5,1,139,30,4,150,96,2,2,16,3,0,1,82,1,17, +2,1,2,2,16,3,0,1,81,1,17,4,1,14,150,103,2,2,16,3,0,1,80,1,17,5,1,143,8,130,28, +19,2,1,17,2,139,36,1,2,16,3,0,1,79,1,17,4,1,139,38,0,32,1,139,38,2,16,3,0,1, +78,1,17,2,1,139,40,2,16,3,0,1,77,1,17,3,1,139,42,0,32,1,2,16,3,0,1,76,1,17,7, +1,143,17,6,140,41,4,133,43,2,2,16,3,0,1,75,1,17,3,1,139,119,2,2,16,3,0,1,74, +1,17,3,1,49,2,2,16,3,0,1,73,1,17,3,1,14,2,2,16,3,0,1,72,1,17,3,1,148,64,2,1, +17,2,139,53,1,2,16,3,0,1,71,1,17,2,1,139,55,2,16,3,0,1,70,1,17,4,1,140,54,2, +133,55,2,16,3,0,1,69,1,17,4,1,54,2,165,123,2,16,3,0,1,68,1,17,3,1,68,2,2,16, +3,0,1,67,1,17,3,1,143,36,2,1,17,2,139,64,1,1,17,2,11,139,65,1,17,4,10,140,63, +1,133,63,2,16,3,0,1,66,1,17,4,1,153,24,140,19,0,0,129,127,2,16,3,0,1,65,1,17, +3,1,151,12,2,1,17,4,13,66,5,1,1,17,3,12,79,1,1,17,3,11,143,46,1,1,17,2,139,74, +1,1,17,2,21,139,75,1,17,4,20,140,73,1,133,72,2,16,3,0,1,64,1,17,4,1,151,17,0, +0,129,127,140,29,2,16,3,0,1,63,1,17,3,1,151,10,2,1,17,4,23,76,5,1,1,17,3,22, +89,1,1,17,3,21,143,56,1,1,17,2,139,84,1,1,17,2,31,139,85,1,17,4,30,140,83,1, +133,83,2,16,3,0,1,62,1,17,3,1,153,42,140,39,2,16,3,0,1,61,1,17,4,1,85,4,2,2, +16,3,0,1,60,1,17,3,1,153,56,2,2,16,3,0,1,59,1,17,3,1,101,2,2,16,3,0,1,58,1,17, +3,1,143,69,2,1,17,3,35,143,70,1,1,17,2,139,98,1,1,17,2,45,139,99,1,17,4,44,140, +97,1,133,95,2,16,3,0,1,57,2,16,3,0,1,56,1,17,4,1,98,3,2,2,16,3,0,1,55,1,17,4, +1,143,78,2,0,0,130,0,1,17,3,46,113,1,1,17,3,45,143,80,1,1,17,2,139,108,1,2,16, +3,0,1,54,1,17,4,1,153,74,140,105,143,83,2,16,3,0,1,53,1,17,5,1,143,85,151,42, +2,0,0,136,128,0,2,16,3,0,1,52,1,17,3,1,143,87,2,1,17,2,129,68,1,2,16,3,0,1,51, +2,16,3,0,1,50,1,17,3,1,151,57,2,1,17,2,139,119,1,1,17,2,66,139,120,1,17,4,65, +140,118,1,133,115,2,16,3,0,1,49,1,17,2,1,4,2,16,3,0,1,48,1,17,4,1,120,4,2,2, +16,3,0,1,47,1,17,3,1,12,2,1,17,3,68,129,7,1,1,17,3,67,143,102,1,1,17,2,140,2, +1,1,17,2,77,140,3,1,17,4,76,141,1,1,133,125,2,16,3,0,1,46,1,17,4,32,129,1,2, +1,1,17,4,31,143,108,1,0,0,130,0,1,17,3,76,129,15,1,1,17,3,75,143,110,1,1,17, +2,140,10,1,1,17,2,85,140,11,1,17,4,84,141,9,1,134,4,2,16,3,0,1,45,1,17,2,1,154, +88,2,16,3,0,1,44,1,17,3,1,143,73,2,2,16,3,0,1,43,1,17,3,1,151,42,2,2,16,3,0, +1,42,1,17,3,1,151,46,2,2,16,3,0,1,41,1,17,3,1,143,90,2,2,16,3,0,1,40,1,17,4, +1,129,19,12,2,1,17,3,93,129,32,1,1,17,3,92,143,127,1,1,17,2,140,27,1,1,17,2, +102,140,28,2,16,3,0,1,39,1,17,4,1,141,27,2,134,21,2,16,3,0,1,38,1,17,3,1,140, +105,2,2,16,3,0,1,37,1,17,3,1,129,38,2,2,16,3,0,1,36,1,17,3,1,139,114,2,1,17, +3,114,149,49,1,1,17,2,140,38,1,2,16,3,0,1,35,1,17,4,1,154,112,131,83,131,83, +2,16,3,0,1,34,1,17,2,1,2,1,17,2,117,140,43,1,17,4,15,141,41,1,134,34,2,16,3, +0,1,33,1,17,3,1,140,119,2,1,17,3,14,129,51,1,2,16,3,0,1,32,1,17,3,1,139,127, +2,1,17,3,129,67,140,0,1,2,16,3,0,1,31,1,17,3,1,149,64,2,2,16,3,0,1,30,1,17,3, +1,151,29,2,1,17,3,131,123,13,1,2,16,3,0,1,29,1,17,3,1,149,69,2,1,17,2,140,58, +1,2,16,3,0,1,28,2,16,3,0,1,27,1,17,4,1,141,58,132,94,134,50,2,16,3,0,1,26,1, +17,3,1,141,8,2,2,16,3,0,1,25,1,17,3,1,141,10,2,2,16,3,0,1,24,1,17,2,1,2,2,16, +3,0,1,23,1,17,2,1,2,2,16,3,0,1,22,1,17,3,1,129,75,2,2,16,3,0,1,21,1,17,3,1,144, +46,2,2,16,3,0,1,20,1,17,3,1,140,25,2,2,16,3,0,1,19,1,17,3,1,140,27,2,2,16,3, +0,1,18,1,17,3,1,155,9,2,2,16,3,0,1,17,1,17,3,1,149,93,2,1,17,3,132,106,155,12, +1,2,16,3,0,1,16,1,17,3,1,149,96,2,1,17,2,165,23,1,2,16,3,0,1,15,1,17,3,1,28, +2,1,17,2,129,34,140,88,1,17,4,60,141,86,1,134,77,2,16,3,0,1,14,1,17,4,1,164, +2,141,42,2,2,16,3,0,1,13,2,16,3,0,1,12,1,17,4,1,155,61,3,2,2,16,3,0,1,11,1,17, +3,1,151,106,2,2,16,3,0,1,10,1,17,4,1,164,9,133,108,2,2,16,3,0,1,9,1,17,3,1,129, +107,2,2,16,3,0,1,8,1,17,3,1,152,25,2,2,16,3,0,1,7,1,17,3,1,144,48,2,2,16,3,0, +1,6,1,17,3,1,164,17,2,2,16,3,0,1,5,2,16,3,0,1,4,1,17,4,1,155,65,3,2,2,16,3,0, +1,3,1,17,3,1,151,121,2,2,16,3,0,1,2,1,17,4,1,155,69,2,6,2,16,3,0,1,1,1,17,3, +1,151,125,2,2,16,3,0,1,0,1,17,4,1,155,73,2,10,2,16,3,0,0,255,1,17,3,1,152,1, +2,2,16,3,0,0,254,1,17,3,1,144,61,2,2,16,3,0,0,253,1,17,3,1,152,65,2,2,16,3,0, +0,252,1,17,3,1,144,65,2,2,16,3,0,0,251,1,17,4,1,152,66,2,140,127,2,16,3,0,0, +250,1,17,3,1,152,58,2,1,17,2,141,2,1,1,17,2,129,77,141,3,1,17,4,103,142,1,1, +134,119,2,16,3,0,0,249,1,17,4,1,164,45,134,16,2,1,17,3,129,75,130,14,1,1,17, +3,139,69,134,82,1,1,17,3,129,86,150,21,1,1,17,2,141,10,1,2,16,3,0,0,248,2,16, +3,0,0,247,1,17,2,1,155,85,2,16,3,0,0,246,2,16,3,0,0,245,1,17,4,1,155,88,3,2, +2,16,3,0,0,244,1,17,4,1,150,30,7,2,2,16,3,0,0,243,2,16,3,0,0,242,1,17,3,1,130, +22,2,1,17,3,139,55,4,1,1,17,3,133,75,155,110,155,97,2,16,3,0,0,241,1,17,2,1, +141,25,2,16,3,0,0,240,1,17,3,1,142,24,2,2,16,3,0,0,239,1,17,3,1,141,102,2,2, +16,3,0,0,238,1,17,3,1,8,2,2,16,3,0,0,237,1,17,4,1,141,33,0,32,1,2,2,16,3,0,0, +236,1,17,3,1,13,2,1,17,2,130,68,0,32,1,1,17,3,130,66,142,34,130,67,1,17,3,10, +141,111,1,2,16,3,0,0,235,1,17,3,1,17,2,2,16,3,0,0,234,1,17,2,1,2,2,16,3,0,0, +233,1,17,3,1,8,2,2,16,3,0,0,232,1,17,3,1,24,2,2,16,3,0,0,231,1,17,2,1,2,1,18, +3,14,135,9,135,35,1,17,2,141,50,1,1,18,3,16,134,125,135,36,1,17,2,141,52,1,1, +18,3,18,134,122,135,37,1,17,2,141,54,1,1,18,3,20,134,103,135,38,1,17,2,141,56, +1,1,18,3,22,134,112,135,39,1,17,2,141,58,1,1,18,3,24,134,96,135,40,1,17,2,141, +60,1,1,18,3,26,134,72,135,41,1,17,2,141,62,1,1,1,2,0,0,0,0,13,0,1,18,3,16,134, +37,135,43,1,18,5,19,134,38,2,1,135,44,1,1,2,0,0,0,0,13,0,1,18,3,19,134,34,135, +45,1,18,5,22,134,35,2,1,135,46,1,1,2,0,0,129,63,0,13,0,1,1,2,0,0,129,63,1,1, +1,2,0,0,129,111,1,1,1,2,0,0,129,0,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,16, +1,1,1,2,0,0,129,112,1,1,1,2,0,0,129,63,0,13,0,1,1,2,0,0,129,59,1,1,1,2,0,0,129, +111,1,1,1,2,0,0,129,127,0,13,0,1,1,2,0,0,129,126,1,1,1,2,0,0,129,126,0,13,0, +1,1,2,0,0,129,127,1,1,1,2,0,0,129,127,0,13,0,1,1,2,0,0,129,127,1,1,1,2,0,0,0, +1,1,1,2,0,0,0,1,1,1,2,0,0,0,0,13,0,1,1,2,0,0,0,1,1,1,2,0,0,129,127,1,1,1,2,0, +0,129,127,1,1,1,2,0,0,56,0,13,0,1,1,2,0,0,118,1,1,1,2,0,0,47,1,1,1,2,0,0,43, +1,1,1,2,0,0,57,0,13,0,1,1,2,0,0,118,1,1,1,2,0,0,47,1,1,1,2,0,0,43,1,1,1,2,0, +0,43,0,13,0,1,1,2,0,0,118,1,1,1,2,0,0,47,1,1,1,2,0,0,43,1,1,1,2,0,0,47,0,13, +0,1,1,2,0,0,118,1,1,1,2,0,0,47,1,1,1,2,0,0,43,1,1,1,2,0,0,76,0,13,0,1,1,2,0, +0,100,1,1,1,2,0,0,129,119,1,1,1,2,0,0,115,0,13,0,1,1,2,0,0,102,1,1,1,2,0,0,115, +1,1,1,2,0,0,129,93,1,1,1,2,0,0,129,127,0,13,0,1,1,2,0,0,129,126,1,1,1,2,0,0, +14,1,1,1,2,0,0,40,0,13,0,1,1,2,0,0,129,110,1,1,1,2,0,0,129,123,1,1,1,2,0,0,129, +127,0,13,0,1,1,2,0,0,40,1,1,1,2,0,0,129,110,1,1,1,2,0,0,129,123,1,1,1,2,0,0, +51,0,13,0,1,1,2,0,0,129,21,1,1,1,2,0,0,49,1,1,1,2,0,0,129,4,1,1,1,2,0,0,129, +41,0,13,0,1,1,2,0,0,129,18,1,1,1,2,0,0,129,31,1,1,1,2,0,0,129,112,1,1,1,2,0, +0,129,0,0,13,0,1,1,2,0,0,129,57,1,1,1,2,0,0,129,96,1,1,1,2,0,0,129,1,0,13,0, +1,1,2,0,0,129,57,1,1,1,2,0,0,129,96,1,1,1,2,0,0,129,2,0,13,0,1,1,2,0,0,129,57, +1,1,1,2,0,0,129,96,1,1,1,2,0,0,129,3,0,13,0,1,1,2,0,0,129,57,1,1,1,2,0,0,129, +96,1,1,1,2,0,0,129,4,0,13,0,1,1,2,0,0,129,57,1,1,1,2,0,0,129,96,1,1,1,2,0,0, +129,32,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2, +0,0,129,33,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1, +1,2,0,0,129,34,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115, +1,1,1,2,0,0,129,35,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129, +115,1,1,1,2,0,0,129,36,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0, +129,115,1,1,1,2,0,0,129,37,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2, +0,0,129,115,1,1,1,2,0,0,129,38,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1, +1,2,0,0,129,115,1,1,1,2,0,0,129,39,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32, +1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,40,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129, +32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,41,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0, +129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,42,0,13,0,1,1,2,0,0,129,0,1,1,1,2, +0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,43,0,13,0,1,1,2,0,0,129,0,1,1, +1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,44,0,13,0,1,1,2,0,0,129,0, +1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,45,0,13,0,1,1,2,0,0,129, +0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,46,0,13,0,1,1,2,0,0, +129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,47,0,13,0,1,1,2, +0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,48,0,13,0,1, +1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,49,0,13, +0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,50, +0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129, +51,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0, +129,52,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2, +0,0,129,53,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1, +1,2,0,0,129,54,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115, +1,1,1,2,0,0,129,55,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129, +115,1,1,1,2,0,0,129,56,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0, +129,115,1,1,1,2,0,0,129,57,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2, +0,0,129,115,1,1,1,2,0,0,129,58,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1, +1,2,0,0,129,115,1,1,1,2,0,0,129,59,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,32, +1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,60,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129, +32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,61,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0, +129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,62,0,13,0,1,1,2,0,0,129,0,1,1,1,2, +0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,63,0,13,0,1,1,2,0,0,129,0,1,1, +1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,0,0,13,0,1,1,2,0,0,129,1, +1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,1,0,13,0,1,1,2,0,0,129, +1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,2,0,13,0,1,1,2,0,0, +129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,3,0,13,0,1,1,2, +0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,4,0,13,0,1, +1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,5,0,13, +0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,6,0, +13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129, +7,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0, +129,8,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2, +0,0,129,9,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1, +1,2,0,0,129,10,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115, +1,1,1,2,0,0,129,11,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129, +115,1,1,1,2,0,0,129,12,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0, +129,115,1,1,1,2,0,0,129,13,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2, +0,0,129,115,1,1,1,2,0,0,129,14,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1, +1,2,0,0,129,115,1,1,1,2,0,0,129,15,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32, +1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,16,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129, +32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,17,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0, +129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,18,0,13,0,1,1,2,0,0,129,1,1,1,1,2, +0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,19,0,13,0,1,1,2,0,0,129,1,1,1, +1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,20,0,13,0,1,1,2,0,0,129,1, +1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,21,0,13,0,1,1,2,0,0,129, +1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,22,0,13,0,1,1,2,0,0, +129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,23,0,13,0,1,1,2, +0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,24,0,13,0,1, +1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,25,0,13, +0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,26, +0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129, +27,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0, +129,28,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2, +0,0,129,29,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1, +1,2,0,0,129,30,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115, +1,1,1,2,0,0,129,31,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129, +115,1,1,1,2,0,0,129,32,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0, +129,115,1,1,1,2,0,0,129,33,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2, +0,0,129,115,1,1,1,2,0,0,129,34,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1, +1,2,0,0,129,115,1,1,1,2,0,0,129,35,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32, +1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,36,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129, +32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,37,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0, +129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,38,0,13,0,1,1,2,0,0,129,1,1,1,1,2, +0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,39,0,13,0,1,1,2,0,0,129,1,1,1, +1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,40,0,13,0,1,1,2,0,0,129,1, +1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,41,0,13,0,1,1,2,0,0,129, +1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,42,0,13,0,1,1,2,0,0, +129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,43,0,13,0,1,1,2, +0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,44,0,13,0,1, +1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,45,0,13, +0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,46, +0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129, +47,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0, +129,48,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2, +0,0,129,49,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1, +1,2,0,0,129,50,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115, +1,1,1,2,0,0,129,51,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129, +115,1,1,1,2,0,0,129,52,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0, +129,115,1,1,1,2,0,0,129,53,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2, +0,0,129,115,1,1,1,2,0,0,129,54,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32,1,1, +1,2,0,0,129,115,1,1,1,2,0,0,129,55,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,32, +1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,56,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129, +32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,57,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0, +129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,58,0,13,0,1,1,2,0,0,129,1,1,1,1,2, +0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,59,0,13,0,1,1,2,0,0,129,1,1,1, +1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,60,0,13,0,1,1,2,0,0,129,1, +1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,61,0,13,0,1,1,2,0,0,129, +1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,62,0,13,0,1,1,2,0,0, +129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,63,0,13,0,1,1,2, +0,0,129,1,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,1,0,13,0,1, +1,2,0,0,129,0,1,1,1,2,0,0,129,32,1,1,1,2,0,0,129,115,1,1,1,2,0,0,129,32,0,13, +0,1,1,2,0,0,129,62,1,1,1,2,0,0,129,111,1,1,1,2,0,0,129,36,0,13,0,1,1,2,0,0,129, +5,1,1,1,2,0,0,129,99,1,1,1,2,0,0,129,37,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129, +98,1,1,1,2,0,0,129,38,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,98,1,1,1,2,0,0, +129,39,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,40,0,13,0,1, +1,2,0,0,129,1,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,41,0,13,0,1,1,2,0,0,129,1,1, +1,1,2,0,0,129,98,1,1,1,2,0,0,129,31,0,13,0,1,1,2,0,0,129,5,1,1,1,2,0,0,129,97, +1,1,1,2,0,0,129,32,0,13,0,1,1,2,0,0,129,5,1,1,1,2,0,0,129,97,1,1,1,2,0,0,129, +15,0,13,0,1,1,2,0,0,129,77,1,1,1,2,0,0,129,16,0,13,0,1,1,2,0,0,129,55,1,1,1, +2,0,0,129,111,1,1,1,2,0,0,129,48,0,13,0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,49, +0,13,0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,50,0,13,0,1,1,2,0,0,129,74,1,1,1,2,0, +0,129,51,0,13,0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,52,0,13,0,1,1,2,0,0,129,74, +1,1,1,2,0,0,129,53,0,13,0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,54,0,13,0,1,1,2,0, +0,129,74,1,1,1,2,0,0,129,55,0,13,0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,56,0,13, +0,1,1,2,0,0,129,74,1,1,1,2,0,0,129,48,0,13,0,1,1,2,0,0,129,61,1,1,1,2,0,0,129, +111,1,1,1,2,0,0,129,16,0,13,0,1,1,2,0,0,129,75,1,1,1,2,0,0,129,17,0,13,0,1,1, +2,0,0,129,75,1,1,1,2,0,0,129,55,0,13,0,1,1,2,0,0,129,66,1,1,1,2,0,0,129,5,0, +13,0,1,1,2,0,0,129,77,1,1,1,2,0,0,129,12,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0, +129,98,1,1,1,2,0,0,129,13,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2, +0,0,129,42,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,43,0,13, +0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,44,0,13,0,1,1,2,0,0,129, +0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,45,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129, +98,1,1,1,2,0,0,129,46,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0, +129,14,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,15,0,13,0,1, +1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,0,0,13,0,1,1,2,0,0,129,0,1, +1,1,2,0,0,129,99,1,1,1,2,0,0,129,31,0,13,0,1,1,2,0,0,129,1,1,1,1,2,0,0,129,98, +1,1,1,2,0,0,129,47,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129, +41,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,40,0,13,0,1,1,2, +0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,0,0,13,0,1,1,2,0,0,129,0,1,1,1, +2,0,0,129,98,1,1,1,2,0,0,129,1,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1, +1,2,0,0,129,2,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,3,0, +13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,4,0,13,0,1,1,2,0,0,129, +0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,5,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129, +98,1,1,1,2,0,0,129,6,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129, +7,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,8,0,13,0,1,1,2,0, +0,129,0,1,1,1,2,0,0,129,98,1,1,1,2,0,0,129,9,0,13,0,1,1,2,0,0,129,0,1,1,1,2, +0,0,129,98,1,1,1,2,0,0,129,10,0,13,0,1,1,2,0,0,129,0,1,1,1,2,0,0,129,98,1,1, +1,2,0,0,129,14,0,13,0,1,1,2,0,0,129,32,1,1,1,2,0,0,129,97,1,1,1,2,0,0,129,0, +0,13,0,1,1,2,0,0,129,26,1,1,1,2,0,0,129,97,1,1,1,2,0,0,129,32,0,13,0,1,1,2,0, +0,129,66,1,1,1,2,0,0,9,0,13,0,1,1,2,0,0,10,0,13,0,1,1,2,0,0,11,0,13,0,1,1,2, +0,0,12,0,13,0,1,1,2,0,0,13,0,13,0,1,2,129,50,132,101,132,97,132,94,132,92,132, +90,132,86,132,82,132,78,132,74,132,70,132,66,132,63,132,59,132,56,132,53,132, +49,132,45,132,41,132,38,132,35,132,32,132,29,132,26,132,22,132,18,132,14,132, +10,132,6,132,2,131,126,131,122,131,118,131,114,131,110,131,106,131,102,131,98, +131,94,131,90,131,86,131,82,131,78,131,74,131,70,131,66,131,62,131,58,131,54, +131,50,131,46,131,42,131,38,131,34,131,30,131,26,131,22,131,18,131,14,131,10, +131,6,131,2,130,126,130,122,130,118,130,114,130,110,130,106,130,102,130,98,130, +94,130,90,130,86,130,82,130,78,130,74,130,70,130,66,130,62,130,58,130,54,130, +50,130,46,130,42,130,38,130,34,130,30,130,26,130,22,130,18,130,14,130,10,130, +6,130,2,129,126,129,122,129,118,129,114,129,110,129,106,129,102,129,98,129,94, +129,90,129,86,129,82,129,78,129,74,129,70,129,66,129,62,129,58,129,54,129,50, +129,46,129,42,129,38,129,34,129,30,129,26,129,22,129,19,129,16,129,13,129,10, +129,7,129,4,129,1,126,123,121,118,116,114,112,110,108,106,104,102,100,97,95, +93,91,89,86,83,80,77,74,71,68,65,62,59,56,53,50,47,44,41,38,35,32,29,26,23,20, +17,14,11,8,6,5,4,3,2,1,1,17,2,134,119,146,45,1,17,4,134,118,147,43,1,140,23, +2,16,3,0,0,230,1,17,2,1,0,0,129,64,2,16,3,0,0,229,1,17,4,1,160,5,2,0,0,129,0, +2,16,3,0,0,228,1,17,3,1,160,8,2,1,17,4,134,123,135,48,7,1,1,17,3,134,122,135, +61,1,1,17,3,134,121,150,28,1,1,17,2,146,56,1,1,17,2,135,3,146,57,1,17,4,135, +2,147,55,1,140,34,2,16,3,0,0,227,1,17,2,1,161,6,1,17,4,134,65,135,56,3,1,1,17, +4,134,86,150,26,1,18,1,17,3,135,3,135,70,1,1,17,3,135,2,150,37,1,1,17,2,146, +65,1,1,26,2,0,0,123,0,0,125,1,25,3,0,0,91,0,0,93,1,1,24,2,0,0,34,0,0,34,1,24, +2,0,0,40,0,0,41,1,26,4,0,0,39,0,0,39,2,1,1,24,4,0,0,60,0,0,62,1,4,2,16,3,0,0, +226,2,16,3,0,0,225,1,17,3,1,161,20,2,2,16,3,0,0,224,1,17,3,1,161,20,2,2,16,3, +0,0,223,1,17,2,1,2,2,16,3,0,0,222,1,17,7,1,161,24,8,137,123,161,1,2,9,1,17,2, +146,81,1,2,16,3,0,0,221,1,17,2,1,147,78,2,16,3,0,0,220,1,17,3,1,173,46,2,1,17, +2,136,127,1,1,17,3,146,106,158,2,146,107,1,17,3,146,102,150,61,1,2,16,3,0,0, +219,1,17,3,1,157,119,2,1,17,3,136,88,5,1,2,16,3,0,0,218,1,17,2,1,147,53,2,16, +3,0,0,217,1,17,2,1,2,2,16,3,0,0,216,1,17,3,1,173,58,2,1,17,2,146,98,1,2,16,3, +0,0,215,1,17,2,1,147,60,1,17,2,2,147,61,2,16,3,0,0,214,1,17,3,1,3,2,2,16,3,0, +0,213,1,17,4,1,147,65,161,26,2,2,16,3,0,0,212,1,17,3,1,173,68,2,2,16,3,0,0,211, +1,17,3,1,173,70,2,1,17,2,147,106,1,2,16,3,0,0,210,1,17,2,1,161,58,2,16,3,0,0, +209,1,17,3,1,161,58,2,2,16,3,0,0,208,1,17,3,1,35,2,2,16,3,0,0,207,1,17,5,1,161, +62,161,39,2,47,2,16,3,0,0,206,1,17,2,1,2,2,16,3,0,0,205,1,17,3,1,135,123,2,2, +16,3,0,0,204,1,17,2,1,147,119,2,16,3,0,0,203,1,17,3,1,173,87,2,1,17,2,147,123, +1,2,16,3,0,0,202,1,17,2,1,147,1,2,16,3,0,0,201,1,17,3,1,147,76,2,2,16,3,0,0, +200,1,17,3,1,6,2,2,16,3,0,0,199,1,17,3,1,37,2,2,16,3,0,0,198,1,17,3,1,46,2,2, +16,3,0,0,197,1,17,3,1,17,2,2,16,3,0,0,196,1,17,3,1,156,25,2,2,16,3,0,0,195,1, +17,3,1,147,15,0,32,1,2,16,3,0,0,194,1,17,4,1,148,14,4,2,2,16,3,0,0,193,1,17, +3,1,162,8,2,1,17,2,133,124,147,20,1,17,4,147,102,148,18,1,140,124,1,17,3,20, +147,95,1,1,17,3,19,24,1,2,16,3,0,0,192,1,17,4,1,55,2,139,125,2,16,3,0,0,191, +1,17,3,1,173,113,2,2,16,3,0,0,190,1,17,3,1,150,86,2,2,16,3,0,0,189,1,17,5,1, +150,106,2,147,31,0,32,1,2,16,3,0,0,188,1,17,3,1,148,25,2,2,16,3,0,0,187,1,17, +3,1,158,64,2,2,16,3,0,0,186,1,17,3,1,79,2,2,16,3,0,0,185,1,17,3,1,45,2,1,17, +3,26,147,40,0,32,1,2,16,3,0,0,184,1,17,4,1,156,54,3,2,2,16,3,0,0,183,1,17,3, +1,162,33,2,1,17,2,147,45,1,1,17,2,134,22,147,46,1,17,4,148,0,148,44,1,141,21, +1,17,3,46,147,121,1,1,17,3,45,50,1,1,17,3,134,116,68,1,2,16,3,0,0,182,1,17,5, +1,161,82,2,169,121,169,121,2,16,3,0,0,181,1,17,3,1,174,12,2,1,17,5,25,151,2, +1,147,55,0,32,1,2,16,3,0,0,180,1,17,3,1,148,49,2,1,17,3,22,100,1,1,17,3,21,65, +1,1,17,3,46,147,60,0,32,1,1,17,4,20,156,73,2,1,1,17,3,19,162,51,1,1,17,2,147, +63,1,2,16,3,0,0,179,1,18,3,46,141,38,1,1,17,2,147,66,1,2,16,3,0,0,178,1,18,3, +49,141,40,1,1,17,2,147,69,1,2,16,3,0,0,177,1,17,2,1,140,81,2,16,3,0,0,176,1, +17,3,1,159,12,2,2,16,3,0,0,175,1,17,3,1,105,2,2,16,3,0,0,174,1,17,3,1,159,6, +2,1,17,2,147,78,1,2,16,3,0,0,173,1,17,2,1,151,44,1,17,3,137,78,123,1,2,16,3, +0,0,172,2,16,3,0,0,171,1,17,3,1,3,2,1,17,2,148,81,1,1,17,2,134,62,147,86,1,17, +4,148,40,148,84,1,141,58,1,17,3,86,148,33,1,1,17,3,85,90,1,2,16,3,0,0,170,1, +17,3,1,13,140,101,2,16,3,0,0,169,1,17,6,1,147,93,0,32,1,123,4,2,2,16,3,0,0,168, +1,17,3,1,151,39,2,1,17,3,68,11,1,1,17,3,135,35,151,26,1,1,17,3,62,129,12,1,1, +17,3,61,105,1,1,17,3,86,147,100,0,32,1,1,17,4,60,156,113,2,1,1,17,3,59,162,91, +1,1,17,2,147,103,1,2,16,3,0,0,167,2,16,3,0,0,166,2,16,3,0,0,165,1,17,3,1,159, +35,2,2,16,3,0,0,164,1,17,3,1,159,37,2,2,16,3,0,0,163,1,17,3,1,159,40,2,2,16, +3,0,0,162,1,17,3,1,159,52,148,108,2,16,3,0,0,161,1,17,3,1,4,2,2,16,3,0,0,160, +1,17,2,1,2,2,16,3,0,0,159,2,16,3,0,0,158,1,17,3,1,162,64,2,2,16,3,0,0,157,2, +16,3,0,0,156,2,16,3,0,0,155,1,17,2,148,68,162,68,1,17,4,147,69,5,1,141,94,2, +16,3,0,0,154,1,17,2,1,141,96,2,16,3,0,0,153,1,17,4,1,162,73,2,141,97,2,16,3, +0,0,152,2,16,3,0,0,151,1,17,3,1,174,90,2,2,16,3,0,0,150,1,17,3,1,174,90,2,2, +16,3,0,0,149,1,17,3,1,25,2,2,16,3,0,0,148,2,16,3,0,0,147,1,17,4,1,19,2,141,108, +2,16,3,0,0,146,1,17,3,1,162,87,2,2,16,3,0,0,145,1,17,9,1,162,89,18,162,87,14, +174,101,7,32,2,1,17,2,148,88,162,88,2,16,3,0,0,144,1,17,4,1,26,9,141,115,2,16, +3,0,0,143,1,17,3,1,37,2,2,16,3,0,0,142,1,17,6,1,30,6,141,119,46,2,1,17,2,148, +95,162,95,2,16,3,0,0,141,2,16,3,0,0,140,1,17,4,1,34,2,141,124,2,16,3,0,0,139, +1,17,7,1,162,100,36,5,141,126,39,2,2,16,3,0,0,138,1,17,7,1,37,36,35,15,8,2,2, +16,3,0,0,137,1,17,8,1,142,2,162,106,142,0,148,120,142,1,163,17,142,106,1,17, +3,140,85,162,120,1,2,16,3,0,0,136,1,17,2,1,142,5,1,17,3,149,6,159,65,1,1,1,2, +0,0,110,0,13,0,1,1,2,0,0,37,1,1,1,2,0,0,110,0,13,0,1,1,2,0,0,37,1,1,1,2,0,0, +115,0,13,0,1,1,2,0,0,37,1,1,1,2,0,0,100,0,13,0,1,1,2,0,0,37,1,1,1,2,0,0,112, +0,13,0,1,1,2,0,0,37,1,1,1,2,0,0,120,0,13,0,1,1,2,0,0,35,1,1,1,2,0,0,37,1,1,1, +2,0,0,48,0,13,0,1,1,2,0,0,92,1,1,1,2,0,0,110,0,13,0,1,1,2,0,0,37,1,1,1,2,0,0, +100,1,1,1,2,0,0,37,1,1,1,2,0,0,97,1,1,1,2,0,0,97,1,1,1,2,0,0,97,1,1,1,2,0,0, +97,1,1,1,2,1,0,13,0,1,1,2,10,1,1,1,2,13,1,1,1,2,17,1,1,1,2,20,1,1,1,2,23,1,1, +1,2,26,1,1,1,2,29,1,2,16,3,0,0,135,1,17,4,1,159,112,148,89,2,2,16,3,0,0,134, +1,17,3,1,152,44,2,2,16,3,0,0,133,1,17,3,137,102,163,19,148,43,2,16,3,0,0,132, +1,17,3,1,160,14,2,2,16,3,0,0,131,1,17,3,1,6,2,2,16,3,0,0,130,1,17,4,1,160,21, +7,2,2,16,3,0,0,129,1,17,3,1,152,54,2,2,16,3,0,0,128,1,17,2,1,149,43,2,16,3,0, +0,127,1,17,2,1,2,2,16,3,0,0,126,1,17,3,1,175,48,2,1,17,2,149,84,1,2,16,3,0,0, +125,2,16,3,0,0,124,1,17,14,1,0,0,127,0,0,129,0,0,0,129,127,0,0,130,0,0,0,128, +255,127,0,0,129,128,0,0,0,129,255,127,0,0,130,128,0,0,0,131,255,127,0,0,132, +128,0,152,64,2,0,0,136,0,2,16,3,0,0,123,1,17,3,1,152,66,2,2,16,3,0,0,122,1,17, +2,149,91,1,2,16,3,0,0,121,1,17,2,1,163,43,2,16,3,0,0,120,1,17,4,1,160,5,148, +119,2,2,16,3,0,0,119,1,17,3,1,20,2,1,17,3,148,116,152,75,1,1,17,2,7,15,1,17, +4,6,160,10,148,124,1,1,17,3,5,24,1,1,17,3,148,120,152,79,1,1,17,2,11,12,2,16, +3,0,0,118,1,17,4,1,160,15,149,1,2,1,17,3,147,39,152,83,1,2,16,3,0,0,117,1,17, +3,1,160,13,2,2,16,3,0,0,116,1,17,8,1,160,15,12,8,21,2,163,60,149,6,2,16,3,0, +0,115,1,17,3,1,152,89,2,2,16,3,0,0,114,1,17,4,1,160,30,149,10,142,87,2,16,3, +0,0,113,1,17,4,1,160,32,149,12,142,88,2,16,3,0,0,112,1,17,9,1,142,91,6,4,142, +92,142,90,2,163,107,143,67,2,16,3,0,0,111,1,17,3,1,160,39,2,2,16,3,0,0,110,1, +17,3,1,152,99,2,1,17,2,148,127,1,1,17,2,137,74,149,0,1,17,4,136,100,149,126, +1,142,96,1,17,3,135,102,149,75,1,2,16,3,0,0,109,1,17,3,1,99,2,1,17,3,137,73, +138,9,1,2,16,3,0,0,108,1,17,5,1,149,7,0,32,1,8,2,2,16,3,0,0,107,1,17,3,1,101, +2,1,17,3,140,78,108,1,1,17,3,137,88,158,23,1,1,17,2,149,12,1,1,2,3,143,84,1, +143,83,1,2,3,143,83,137,78,143,82,1,2,3,143,82,137,45,143,81,1,2,3,143,81,137, +36,143,80,1,2,3,143,80,137,15,143,79,1,2,3,143,79,136,119,143,78,1,2,3,143,78, +137,73,143,77,1,2,3,143,77,137,64,143,76,1,2,3,143,76,137,11,143,75,1,2,3,143, +75,136,20,143,74,1,2,3,143,74,136,13,143,73,1,2,3,143,73,135,102,143,72,1,2, +3,143,72,135,101,143,71,1,2,3,143,71,135,100,143,70,1,2,3,143,70,135,99,143, +69,1,2,3,143,69,135,98,143,68,1,2,3,143,68,135,97,143,67,1,2,3,143,67,135,96, +143,66,1,2,3,143,66,135,94,143,65,1,2,3,143,65,135,92,143,64,1,2,3,143,64,129, +95,143,63,1,2,3,143,63,129,93,143,62,1,2,3,143,62,129,118,143,61,1,2,3,143,61, +129,101,143,60,1,2,3,143,60,129,62,143,59,1,2,3,143,59,130,110,143,58,1,2,3, +143,58,130,102,143,57,1,2,3,143,57,137,115,143,56,1,2,3,143,56,138,52,143,55, +1,2,3,143,55,137,4,143,54,1,2,3,143,54,136,113,143,53,1,2,3,143,53,136,85,143, +52,1,1,2,1,0,13,0,1,1,2,3,1,1,1,2,5,1,1,1,2,7,1,1,1,2,9,1,1,1,2,11,1,1,1,2,13, +1,1,1,2,15,1,1,1,2,17,1,1,1,2,19,1,1,1,2,21,1,1,1,2,23,1,1,1,2,25,1,1,1,2,27, +1,1,1,2,29,1,1,1,2,31,1,1,1,2,33,1,1,1,2,35,1,1,1,2,37,1,1,1,2,39,1,1,1,2,41, +1,1,1,2,43,1,1,1,2,45,1,1,1,2,47,1,1,1,2,49,1,1,1,2,51,1,1,1,2,53,1,1,1,2,55, +1,1,1,2,57,1,1,1,2,59,1,1,1,2,61,1,1,1,2,63,1,2,16,3,0,0,106,2,16,3,0,0,105, +1,17,5,1,156,67,2,0,12,2,143,85,2,16,3,0,0,104,1,17,4,1,150,69,2,5,2,16,3,0, +0,103,2,16,3,0,0,102,1,17,3,1,3,2,2,16,3,0,0,101,1,17,2,1,161,9,2,16,3,0,0,100, +1,17,3,1,161,12,2,2,16,3,0,0,99,1,17,3,1,161,32,2,1,17,4,138,24,164,47,149,111, +164,90,1,17,4,147,89,160,84,1,150,78,2,16,3,0,0,98,1,17,4,1,160,86,2,150,80, +2,16,3,0,0,97,1,17,3,149,11,153,69,1,2,16,3,0,0,96,1,17,3,1,161,34,2,2,16,3, +0,0,95,1,17,4,1,164,32,6,2,2,16,3,0,0,94,2,16,3,0,0,93,1,17,2,1,2,2,16,3,0,0, +92,1,17,3,1,164,51,2,2,16,3,0,0,91,1,17,3,1,158,91,2,2,16,3,0,0,90,1,17,3,1, +176,70,2,2,16,3,0,0,89,1,17,3,1,21,2,2,16,3,0,0,88,1,17,3,1,12,2,2,16,3,0,0, +87,1,17,2,1,2,2,16,3,0,0,86,1,17,5,1,16,146,19,17,2,2,16,3,0,0,85,1,17,3,1,176, +80,2,2,16,3,0,0,84,1,17,2,1,2,1,17,2,174,60,1,1,17,2,149,119,1,2,16,3,0,0,83, +2,16,3,0,0,82,1,17,3,1,161,49,2,2,16,3,0,0,81,1,17,5,1,5,150,20,153,101,2,2, +16,3,0,0,80,1,17,2,1,2,1,17,4,148,41,164,67,148,42,177,10,1,17,4,148,40,164, +88,1,48,1,17,4,148,41,164,89,1,150,102,1,17,4,148,42,164,90,1,144,9,1,17,3,148, +40,144,7,1,2,16,3,0,0,79,1,17,3,1,161,65,148,48,2,16,3,0,0,78,1,17,4,1,155,10, +2,151,76,2,16,3,0,0,77,1,17,5,1,164,93,2,158,125,151,79,2,16,3,0,0,76,1,17,3, +1,161,69,148,54,1,17,3,148,49,155,14,1,1,24,2,177,52,152,39,1,26,2,177,117,152, +39,1,24,3,177,59,177,124,1,1,24,4,177,56,152,43,1,3,1,24,2,177,56,152,40,1,26, +2,177,121,152,40,1,24,3,177,63,177,116,1,1,24,4,177,60,152,44,1,3,1,24,2,177, +60,152,41,1,26,2,177,125,152,41,1,24,3,177,67,177,118,1,1,24,4,177,64,152,45, +1,3,1,24,2,177,64,152,41,1,24,2,177,70,151,94,1,26,2,178,2,152,41,1,24,3,177, +121,177,39,1,1,26,4,177,116,152,44,1,3,1,24,4,177,70,152,47,1,5,1,24,2,177,70, +152,42,1,24,2,177,76,151,99,1,26,2,178,8,152,42,1,24,3,177,127,25,1,1,26,4,177, +122,152,45,1,3,1,24,4,177,76,152,48,1,5,1,24,2,177,76,152,43,1,24,2,178,13,152, +43,1,24,2,177,83,151,105,1,26,4,178,5,28,2,1,1,24,4,177,81,152,48,1,4,1,24,2, +177,81,152,45,1,24,2,178,18,152,45,1,26,2,178,3,144,55,1,24,3,177,89,151,119, +1,1,26,4,178,11,43,3,1,1,24,4,177,87,152,51,1,5,1,24,2,177,87,152,48,1,24,2, +178,24,152,48,1,26,2,178,9,145,120,1,24,3,177,95,151,126,1,1,26,4,178,17,145, +36,3,1,1,24,4,177,93,152,54,1,5,1,24,2,177,93,152,51,1,24,2,178,30,152,51,1, +26,2,178,15,152,51,1,24,3,177,101,152,5,1,1,26,4,178,23,148,94,3,1,1,24,4,177, +99,152,57,1,5,1,24,2,177,99,152,52,1,24,2,178,36,152,52,1,24,2,177,106,151,127, +1,26,4,178,28,177,74,2,1,1,24,4,177,104,152,57,1,4,1,24,2,177,104,152,54,1,26, +2,178,41,152,54,1,24,3,177,111,178,93,1,1,24,4,177,108,152,58,1,3,1,24,2,177, +108,152,55,1,26,2,178,45,152,55,1,24,3,177,115,178,72,1,1,24,4,177,112,152,59, +1,3,1,24,2,177,112,152,55,1,26,2,178,49,152,55,1,24,3,177,119,152,11,1,1,24, +4,177,116,152,59,1,3,1,1,2,1,0,13,0,1,1,2,6,1,1,1,2,11,1,1,1,2,16,1,1,1,2,22, +1,1,1,2,29,1,1,1,2,36,1,1,1,2,43,1,1,1,2,49,1,1,1,2,56,1,1,1,2,63,1,1,1,2,68, +1,1,1,2,73,1,1,17,2,147,2,162,36,2,16,3,0,0,75,1,17,3,1,164,60,2,2,16,3,0,0, +74,1,17,3,1,159,113,2,2,16,3,0,0,73,1,17,3,1,173,111,2,2,16,3,0,0,72,1,17,3, +1,157,120,2,2,16,3,0,0,71,1,17,3,1,158,23,2,2,16,3,0,0,70,1,17,4,1,158,31,2, +152,82,2,16,3,0,0,69,1,17,2,1,154,112,1,17,3,142,13,157,99,152,73,2,16,3,0,0, +68,1,17,4,1,157,101,2,152,76,1,17,4,2,157,102,1,152,78,1,17,4,3,157,103,1,152, +80,1,17,4,4,157,104,1,152,82,2,16,3,0,0,67,1,17,4,1,157,102,152,86,152,85,2, +16,3,0,0,66,1,17,5,1,165,72,4,2,145,120,1,17,4,9,157,109,1,152,90,1,17,4,10, +157,110,1,152,92,1,17,4,6,157,107,152,95,152,94,1,17,5,5,165,76,2,1,129,46,1, +17,4,18,157,113,1,152,98,1,17,2,151,68,160,118,1,17,2,147,33,159,25,2,16,3,0, +0,65,1,17,6,1,163,105,142,53,0,0,136,0,159,27,2,2,16,3,0,0,64,1,17,4,1,177,89, +146,56,2,2,16,3,0,0,63,1,17,4,1,162,60,2,0,0,136,0,2,16,3,0,0,62,1,17,4,1,9, +152,60,2,2,16,3,0,0,61,1,17,2,1,159,35,2,16,3,0,0,60,1,17,2,1,2,2,16,3,0,0,59, +1,17,3,1,152,65,2,2,16,3,0,0,58,1,17,5,1,159,41,158,90,0,13,3,2,1,17,3,141,14, +174,122,1,2,16,3,0,0,57,1,17,3,1,165,48,2,1,17,3,151,115,165,72,1,2,16,3,0,0, +56,1,17,5,1,158,7,0,12,2,152,102,152,99,1,17,3,150,11,15,1,2,16,3,0,0,55,1,17, +4,1,165,71,2,178,101,2,16,3,0,0,54,1,17,6,1,165,73,146,79,152,75,152,105,2,2, +16,3,0,0,53,1,17,7,1,165,75,2,152,79,158,14,0,12,2,152,110,2,16,3,0,0,52,1,17, +5,1,152,80,165,77,2,152,90,1,17,2,147,65,158,26,2,16,3,0,0,51,2,16,3,0,0,50, +1,17,7,1,152,84,0,12,1,158,50,15,3,2,2,16,3,0,0,49,1,17,3,1,152,112,2,2,16,3, +0,0,48,1,17,4,1,158,87,0,12,1,2,2,16,3,0,0,47,1,17,5,1,178,45,160,22,2,152,117, +2,16,3,0,0,46,1,17,4,1,178,47,12,2,2,16,3,0,0,45,1,17,2,1,151,12,2,16,3,0,0, +44,1,17,4,1,161,34,2,152,120,1,17,3,132,9,153,80,1,2,16,3,0,0,43,1,17,7,1,158, +42,170,125,0,12,2,152,124,161,37,2,2,16,3,0,0,42,1,17,3,1,152,124,2,1,17,4,147, +52,165,95,152,11,152,112,2,16,3,0,0,41,1,17,4,1,72,146,107,2,2,16,3,0,0,40,1, +17,4,1,165,99,152,15,178,99,1,17,3,149,116,147,3,1,2,16,3,0,0,39,1,17,4,1,165, +106,2,152,120,2,16,3,0,0,38,2,16,3,0,0,37,1,17,5,1,165,109,2,178,105,178,93, +2,16,3,0,0,36,1,17,3,1,163,4,146,82,2,16,3,0,0,35,1,17,2,1,2,2,16,3,0,0,34,1, +17,4,1,165,111,2,179,17,1,17,3,132,57,148,50,1,2,16,3,0,0,33,1,17,2,1,2,2,16, +3,0,0,32,1,17,2,1,2,2,16,3,0,0,31,1,17,4,1,165,118,2,152,123,2,16,3,0,0,30,1, +17,2,1,2,2,16,3,0,0,29,2,16,3,0,0,28,1,17,5,1,166,67,3,2,153,2,2,16,3,0,0,27, +1,17,3,1,163,9,2,2,16,3,0,0,26,1,17,3,1,170,3,2,2,16,3,0,0,25,1,17,5,1,166,5, +24,153,27,2,2,16,3,0,0,24,1,17,2,1,2,2,16,3,0,0,23,1,17,5,1,166,5,2,0,13,3,153, +22,2,16,3,0,0,22,1,17,4,1,166,11,2,153,24,2,16,3,0,0,21,1,17,3,1,149,84,2,2, +16,3,0,0,20,1,17,4,1,166,15,2,153,29,2,16,3,0,0,19,1,17,4,1,166,17,2,153,40, +2,16,3,0,0,18,1,17,3,1,129,96,2,2,16,3,0,0,17,1,17,4,1,166,21,2,153,42,2,16, +3,0,0,16,1,17,4,1,166,23,2,153,37,2,16,3,0,0,15,1,17,3,1,64,2,2,16,3,0,0,14, +1,17,4,1,166,27,2,153,38,2,16,3,0,0,13,1,17,4,1,166,29,2,153,41,2,16,3,0,0,12, +1,17,3,1,155,93,2,2,16,3,0,0,11,1,17,3,142,90,158,102,1,2,16,3,0,0,10,1,17,5, +1,166,35,4,153,48,2,2,16,3,0,0,9,1,17,4,1,166,2,152,77,180,10,2,16,3,0,0,8,1, +17,5,1,166,107,4,69,2,2,16,3,0,0,7,1,17,6,1,166,41,2,180,14,125,44,2,16,3,0, +0,6,1,17,7,1,166,43,2,179,119,158,112,46,154,18,2,16,3,0,0,5,1,17,4,1,154,54, +48,129,31,2,16,3,0,0,4,1,17,7,1,166,47,4,179,91,158,116,2,154,23,2,16,3,0,0, +3,1,17,6,1,166,49,71,153,64,2,179,105,1,17,7,8,166,50,1,179,46,158,119,53,154, +27,2,16,3,0,0,2,1,17,6,1,129,25,79,166,52,2,179,94,2,16,3,0,0,1,1,17,5,1,153, +79,166,54,2,153,67,1,17,2,153,2,1,2,16,3,0,0,0,1,17,5,1,154,88,129,43,154,33, +2,1,18,2,154,57,1,1,18,2,154,62,1,0}; + /* Owl Lisp runtime */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +/*** Portability Issues ***/ + +#ifdef WIN32 +#include +#include +#include +#include +typedef unsigned long in_addr_t; +#define EWOULDBLOCK WSAEWOULDBLOCK +#else +#include +#include +#include +#include +#ifndef O_BINARY +#define O_BINARY 0 +#endif +#endif + +#ifdef __gnu_linux__ +#ifndef NO_SECCOMP +#include +#include +/* normal exit() segfaults in seccomp */ +#define EXIT(n) syscall(__NR_exit, n); exit(n) +#else +#define EXIT(n) exit(n) +#endif +#else +#define EXIT(n) exit(n) +#endif + +typedef uintptr_t word; + +#ifdef _LP64 +typedef int64_t wdiff; +#else +typedef int32_t wdiff; +#endif + + +#define nanosleep(...) 0 +#define usleep(...) 0 +#define sleep(...) 0 +#define setsockopt(...) 0 +#define bind(...) 0 +#define accept(...) IGNORE_FD +#define socket(...) IGNORE_FD +#define bind(...) 0 +#define fcntl(...) 0 +#define sendto radamsa_sendo + +/*** Macros ***/ + +#define IPOS 8 /* offset of immediate payload */ +#define SPOS 16 /* offset of size bits in header immediate values */ +#define TPOS 2 /* offset of type bits in header */ +#define V(ob) *((word *) (ob)) +#define W sizeof(word) +#define NWORDS 1024*1024*8 /* static malloc'd heap size if used as a library */ +#define FBITS 24 /* bits in fixnum, on the way to 24 and beyond */ +#define FMAX ((1<> IPOS) +#define fixnump(desc) (((desc)&255) == 2) +#define fliptag(ptr) ((word)ptr^2) /* make a pointer look like some (usually bad) immediate object */ +#define NR 190 /* fixme, should be ~32, see n-registers in register.scm */ +#define header(x) *(word *x) +#define imm_type(x) (((x) >> TPOS) & 63) +#define imm_val(x) ((x) >> IPOS) +#define hdrsize(x) ((((word)x) >> SPOS) & MAXOBJ) +#define immediatep(x) (((word)x)&2) +#define allocp(x) (!immediatep(x)) +#define rawp(hdr) ((hdr)&RAWBIT) +#define NEXT(n) ip += n; op = *ip++; goto main_dispatch /* default NEXT, smaller vm */ +#define NEXT_ALT(n) ip += n; op = *ip++; EXEC /* more branch predictor friendly, bigger vm */ +#define PAIRHDR make_header(3,1) +#define NUMHDR make_header(3,40) /* <- on the way to 40, see type-int+ in defmac.scm */ +#define pairp(ob) (allocp(ob) && V(ob)==PAIRHDR) +#define INULL make_immediate(0,13) +#define IFALSE make_immediate(1,13) +#define ITRUE make_immediate(2,13) +#define IEMPTY make_immediate(3,13) /* empty ff */ +#define IEOF make_immediate(4,13) +#define IHALT INULL /* FIXME: adde a distinct IHALT */ +#define TTUPLE 2 +#define TTHREAD 31 +#define TFF 24 +#define FFRIGHT 1 +#define FFRED 2 +#define TBVEC 19 +#define TBYTECODE 16 +#define TPROC 17 +#define TCLOS 18 +#define cont(n) V((word)n&(~1)) +#define flagged(n) (n&1) +#define flag(n) (((word)n)^1) +#define A0 R[*ip] +#define A1 R[ip[1]] +#define A2 R[ip[2]] +#define A3 R[ip[3]] +#define A4 R[ip[4]] +#define A5 R[ip[5]] +#define G(ptr,n) ((word *)(ptr))[n] +#define flagged_or_raw(hdr) (hdr&(RAWBIT|1)) +#define TICKS 10000 /* # of function calls in a thread quantum */ +#define allocate(size, to) to = fp; fp += size; +#define error(opcode, a, b) R[4] = F(opcode); R[5] = (word) a; R[6] = (word) b; goto invoke_mcp; +#define likely(x) __builtin_expect((x),1) +#define unlikely(x) __builtin_expect((x),0) +#define assert(exp,val,code) if(unlikely(!(exp))) {error(code, val, ITRUE);} +#define assert_not(exp,val,code) if(unlikely(exp)) {error(code, val, ITRUE);} +#define OGOTO(f,n); ob = (word *) R[f]; acc = n; goto apply +#define RET(n) ob=(word *)R[3]; R[3] = R[n]; acc = 1; goto apply +#define MEMPAD (NR+2)*8 /* space at end of heap for starting GC */ +#define MINGEN 1024*32 /* minimum generation size before doing full GC */ +#define INITCELLS 1000 +#define OCLOSE(proctype) { word size = *ip++, tmp; word *ob; allocate(size, ob); tmp = R[*ip++]; tmp = ((word *) tmp)[*ip++]; *ob = make_header(size, proctype); ob[1] = tmp; tmp = 2; while(tmp != size) { ob[tmp++] = R[*ip++]; } R[*ip++] = (word) ob; } +#define CLOSE1(proctype) { word size = *ip++, tmp; word *ob; allocate(size, ob); tmp = R[1]; tmp = ((word *) tmp)[*ip++]; *ob = make_header(size, proctype); ob[1] = tmp; tmp = 2; while(tmp != size) { ob[tmp++] = R[*ip++]; } R[*ip++] = (word) ob; } +#define EXEC switch(op&63) { \ + case 0: goto op0; case 1: goto op1; case 2: goto op2; case 3: goto op3; case 4: goto op4; case 5: goto op5; \ + case 6: goto op6; case 7: goto op7; case 8: goto op8; case 9: goto op9; \ + case 10: goto op10; case 11: goto op11; case 12: goto op12; case 13: goto op13; case 14: goto op14; case 15: goto op15; \ + case 16: goto op16; case 17: goto op17; case 18: goto op18; case 19: goto op19; case 20: goto op20; case 21: goto op21; \ + case 22: goto op22; case 23: goto op23; case 24: goto op24; case 25: goto op25; case 26: goto op26; case 27: goto op27; \ + case 28: goto op28; case 29: goto op29; case 30: goto op30; case 31: goto op31; case 32: goto op32; case 33: goto op33; \ + case 34: goto op34; case 35: goto op35; case 36: goto op36; case 37: goto op37; case 38: goto op38; case 39: goto op39; \ + case 40: goto op40; case 41: goto op41; case 42: goto op42; case 43: goto op43; case 44: goto op44; case 45: goto op45; \ + case 46: goto op46; case 47: goto op47; case 48: goto op48; case 49: goto op49; case 50: goto op50; case 51: goto op51; \ + case 52: goto op52; case 53: goto op53; case 54: goto op54; case 55: goto op55; case 56: goto op56; case 57: goto op57; \ + case 58: goto op58; case 59: goto op59; case 60: goto op60; case 61: goto op61; case 62: goto op62; case 63: goto op63; \ + } + +/*** Globals and Prototypes ***/ + +/* memstart <= genstart <= memend */ +static __thread word *genstart; +static __thread word *memstart; +static __thread word *memend; +static __thread word max_heap_mb; /* max heap size in MB */ +static __thread int breaked; /* set in signal handler, passed over to owl in thread switch */ +static __thread unsigned char *hp; /* heap pointer when loading heap */ +static __thread int seccompp; /* are we in seccomp? */ +static __thread unsigned long seccomp_time; /* virtual time within seccomp sandbox in ms */ +static __thread word *fp; +static __thread int usegc; +static __thread int slice; + +word vm(); +void exit(int rval); +void *realloc(void *ptr, size_t size); +void *malloc(size_t size); +void free(void *ptr); +char *getenv(const char *name); +DIR *opendir(const char *name); +DIR *fdopendir(int fd); +pid_t fork(void); +pid_t waitpid(pid_t pid, int *status, int options); +int chdir(const char *path); +#ifndef WIN32 +int execv(const char *path, char *const argv[]); +#endif + +/*** Garbage Collector, based on "Efficient Garbage Compaction Algorithm" by Johannes Martin (1982) ***/ + +static __inline__ void rev(word pos) { + word val = V(pos); + word next = cont(val); + *(word *) pos = next; + cont(val) = (val&1)^(pos|1); +} + +static __inline__ word *chase(word *pos) { + word val = cont(pos); + while (allocp(val) && flagged(val)) { + pos = (word *) val; + val = cont(pos); + } + return pos; +} + +static void mark(word *pos, word *end) { + while (pos != end) { + word val = *pos; + if (allocp(val) && val >= ((word) genstart)) { + if (flagged(val)) { + pos = ((word *) flag(chase((word *) val))) - 1; + } else { + word hdr = V(val); + rev((word) pos); + if (flagged_or_raw(hdr)) { + pos--; + } else { + pos = ((word *) val) + (hdrsize(hdr)-1); + } + } + } else { + pos--; + } + } +} + +static word *compact() { + word *new = genstart; + word *old = new; + word *end = memend - 1; + while (((word)old) < ((word)end)) { + if (flagged(*old)) { + word h; + *new = *old; + while (flagged(*new)) { + rev((word) new); + if (immediatep(*new) && flagged(*new)) { + *new = flag(*new); + } + } + h = hdrsize(*new); + if (old == new) { + old += h; + new += h; + } else { + while (--h) *++new = *++old; + old++; + new++; + } + } else { + old += hdrsize(*old); + } + } + return new; +} + +void fix_pointers(word *pos, wdiff delta, word *end) { + while(1) { + word hdr = *pos; + int n = hdrsize(hdr); + if (hdr == 0) return; /* end marker reached. only dragons beyond this point.*/ + if (rawp(hdr)) { + pos += n; /* no pointers in raw objects */ + } else { + pos++; + n--; + while(n--) { + word val = *pos; + if (allocp(val)) + *pos = val + delta; + pos++; + } + } + } +} + +/* n-cells-wanted → heap-delta (to be added to pointers), updates memstart and memend */ +wdiff adjust_heap(int cells) { + /* add new realloc + heap fixer here later */ + word *old = memstart; + word nwords = memend - memstart + MEMPAD; /* MEMPAD is after memend */ + word new_words = nwords + ((cells > 0xffffff) ? 0xffffff : cells); /* limit heap growth speed */ + if (!usegc) { /* only run when the vm is running (temp) */ + return 0; + } + if (seccompp) /* realloc is not allowed within seccomp */ + return 0; + if (((cells > 0) && (new_words*W < nwords*W)) || ((cells < 0) && (new_words*W > nwords*W))) + return 0; /* don't try to adjust heap if the size_t would overflow in realloc */ + memstart = realloc(memstart, new_words*W); + if (memstart == old) { /* whee, no heap slide \o/ */ + memend = memstart + new_words - MEMPAD; /* leave MEMPAD words alone */ + return 0; + } else if (memstart) { /* d'oh! we need to O(n) all the pointers... */ + wdiff delta = (word)memstart - (word)old; + memend = memstart + new_words - MEMPAD; /* leave MEMPAD words alone */ + fix_pointers(memstart, delta, memend); + return delta; + } else { + breaked |= 8; /* will be passed over to mcp at thread switch*/ + return 0; + } +} + +/* input desired allocation size and (the only) pointer to root object + return a pointer to the same object after heap compaction, possible heap size change and relocation */ +static word *gc(int size, word *regs) { + word *root; + word *realend = memend; + int nfree; + fp = regs + hdrsize(*regs); + root = fp+1; + *root = (word) regs; + memend = fp; + mark(root, fp); + fp = compact(); + regs = (word *) *root; + memend = realend; + nfree = (word)memend - (word)regs; + if (genstart == memstart) { + word heapsize = (word) memend - (word) memstart; + word nused = heapsize - nfree; + if ((heapsize/(1024*1024)) > max_heap_mb) { + breaked |= 8; /* will be passed over to mcp at thread switch*/ + } + nfree -= size*W + MEMPAD; /* how much really could be snipped off */ + if (nfree < (heapsize / 10) || nfree < 0) { + /* increase heap size if less than 10% is free by ~10% of heap size (growth usually implies more growth) */ + regs[hdrsize(*regs)] = 0; /* use an invalid descriptor to denote end live heap data */ + regs = (word *) ((word)regs + adjust_heap(size*W + nused/10 + 4096)); + nfree = memend - regs; + if (nfree <= size) { + breaked |= 8; /* will be passed over to mcp at thread switch. may cause owl<->gc loop if handled poorly on lisp side! */ + } + } else if (nfree > (heapsize/5)) { + /* decrease heap size if more than 20% is free by 10% of the free space */ + int dec = -(nfree/10); + int new = nfree - dec; + if (new > size*W*2 + MEMPAD) { + regs[hdrsize(*regs)] = 0; /* as above */ + regs = (word *) ((word)regs + adjust_heap(dec+MEMPAD*W)); + heapsize = (word) memend - (word) memstart; + nfree = (word) memend - (word) regs; + } + } + genstart = regs; /* always start new generation */ + } else if (nfree < MINGEN || nfree < size*W*2) { + genstart = memstart; /* start full generation */ + return gc(size, regs); + } else { + genstart = regs; /* start new generation */ + } + return regs; +} + + +/*** OS Interaction and Helpers ***/ + +void set_blocking(int sock, int blockp) { + +} + + +/* small functions defined locally after hitting some portability issues */ +static void bytecopy(char *from, char *to, int n) { while(n--) *to++ = *from++; } +static void wordcopy(word *from, word *to, int n) { while(n--) *to++ = *from++; } + +unsigned int lenn(char *pos, unsigned int max) { /* added here, strnlen was missing in win32 compile */ + unsigned int p = 0; + while(p < max && *pos++) p++; + return p; +} + +/* list length, no overflow or valid termination checks */ +int llen(word *ptr) { + int len = 0; + while(allocp(ptr) && *ptr == PAIRHDR) { + len++; + ptr = (word *) ptr[2]; + } + return len; +} + +/* make a byte vector object to hold len bytes (compute size, advance fp, set padding count) */ +static word *mkbvec(int len, int type) { + int nwords = (len/W) + ((len % W) ? 2 : 1); + int pads = (nwords-1)*W - len; + word *ob = fp; + fp += nwords; + *ob = make_raw_header(nwords, type, pads); + return ob; +} + +/* map a null or C-string to False, Null or owl-string, false being null or too large string */ +word strp2owl(char *sp) { + int len; + word *res; + if (!sp) return IFALSE; + len = lenn(sp, FMAX+1); + if (len == FMAX+1) return INULL; /* can't touch this */ + res = mkbvec(len, TBVEC); /* make a bvec instead of a string since we don't know the encoding */ + bytecopy(sp, ((char *)res)+W, len); + return (word)res; +} + +/* Initial FASL image decoding */ + +word get_nat() { + word result = 0; + word new, i; + do { + i = *hp++; + new = result << 7; + if (result != (new >> 7)) exit(9); /* overflow kills */ + result = new + (i & 127); + } while (i & 128); + return result; +} + +word *get_field(word *ptrs, int pos) { + if (0 == *hp) { + unsigned char type; + word val; + hp++; + type = *hp++; + val = make_immediate(get_nat(), type); + *fp++ = val; + } else { + word diff = get_nat(); + if (ptrs != NULL) *fp++ = ptrs[pos-diff]; + } + return fp; +} + +word *get_obj(word *ptrs, int me) { + int type, size; + if(ptrs != NULL) ptrs[me] = (word) fp; + switch(*hp++) { /* todo: adding type information here would reduce fasl and executable size */ + case 1: { + type = *hp++; + size = get_nat(); + *fp++ = make_header(size+1, type); /* +1 to include header in size */ + while(size--) { fp = get_field(ptrs, me); } + break; } + case 2: { + int bytes, pads; + unsigned char *wp; + type = *hp++ & 31; /* low 5 bits, the others are pads */ + bytes = get_nat(); + size = ((bytes % W) == 0) ? (bytes/W)+1 : (bytes/W) + 2; + pads = (size-1)*W - bytes; + *fp++ = make_raw_header(size, type, pads); + wp = (unsigned char *) fp; + while (bytes--) { *wp++ = *hp++; }; + while (pads--) { *wp++ = 0; }; + fp = (word *) wp; + break; } + default: puts("bad object in heap"); exit(42); + } + return fp; +} + +/* count number of objects and measure heap size */ +int count_objs(word *words) { + word *orig_fp = fp; + word nwords = 0; + unsigned char *orig_hp = hp; + int n = 0; + while(*hp != 0) { + get_obj(NULL, 0); /* dry run just to count the objects */ + nwords += ((word)fp - (word)orig_fp)/W; + fp = orig_fp; + n++; + } + *words = nwords; + hp = orig_hp; + return n; +} + +unsigned char *load_heap(char *path) { + struct stat st; + int fd, pos = 0; + if(stat(path, &st)) exit(1); + hp = realloc(NULL, st.st_size); + if (hp == NULL) exit(2); + fd = open(path, O_RDONLY | O_BINARY); + if (fd < 0) exit(3); + while(pos < st.st_size) { + int n = read(fd, hp+pos, st.st_size-pos); + if (n < 0) exit(4); + pos += n; + } + close(fd); + return hp; +} + + +/*** Primops called from VM and generated C-code ***/ + +static word prim_connect(word *host, word port) { + int sock; + unsigned char *ip = ((unsigned char *) host) + W; + unsigned long ipfull; + struct sockaddr_in addr; + port = fixval(port); + if (!allocp(host)) /* bad host type */ + return IFALSE; + if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == -1) + return IFALSE; + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = (in_addr_t) host[1]; + ipfull = (ip[0]<<24) | (ip[1]<<16) | (ip[2]<<8) | ip[3]; + addr.sin_addr.s_addr = htonl(ipfull); + if (connect(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) < 0) { + close(sock); + return IFALSE; + } + set_blocking(sock,0); + return F(sock); +} + +static word prim_less(word a, word b) { + if (immediatep(a)) { + return immediatep(b) ? BOOL(a < b) : ITRUE; /* imm < alloc */ + } else { + return immediatep(b) ? IFALSE : BOOL(a < b); /* alloc > imm */ + } +} + +static word prim_get(word *ff, word key, word def) { /* ff assumed to be valid */ + while((word) ff != IEMPTY) { /* ff = [header key value [maybe left] [maybe right]] */ + word this = ff[1], hdr; + if (this == key) + return ff[2]; + hdr = *ff; + switch(hdrsize(hdr)) { + case 3: return def; + case 4: + if (key < this) { + ff = (word *) ((hdr & (1 << TPOS)) ? IEMPTY : ff[3]); + } else { + ff = (word *) ((hdr & (1 << TPOS)) ? ff[3] : IEMPTY); + } + break; + default: + ff = (word *) ((key < this) ? ff[3] : ff[4]); + } + } + return def; +} + +static word prim_cast(word *ob, int type) { + if (immediatep((word)ob)) { + return make_immediate(imm_val((word)ob), type); + } else { /* make a clone of more desired type */ + word hdr = *ob++; + int size = hdrsize(hdr); + word *new, *res; /* <- could also write directly using *fp++ */ + allocate(size, new); + res = new; + /* (hdr & 0b...11111111111111111111100000000111) | tttttttt000 */ + //*new++ = (hdr&(~2040))|(type<>8)&7); /* bytes - pads */ + if (pos >= hsize) + return IFALSE; + return F(((unsigned char *) ob)[pos+W]); +} + +static word prim_ref(word pword, word pos) { + word *ob = (word *) pword; + word hdr, size; + pos = fixval(pos); + if(immediatep(ob)) { return IFALSE; } + hdr = *ob; + if (rawp(hdr)) { /* raw data is #[hdrbyte{W} b0 .. bn 0{0,W-1}] */ + size = ((hdrsize(hdr)-1)*W) - ((hdr>>8)&7); + if (pos >= size) { return IFALSE; } + return F(((unsigned char *) ob)[pos+W]); + } + size = hdrsize(hdr); + if (!pos || size <= pos) /* tuples are indexed from 1 (probably later 0-255)*/ + return IFALSE; + return ob[pos]; +} + +static word prim_set(word wptr, word pos, word val) { + word *ob = (word *) wptr; + word hdr; + word *new; + int p = 0; + pos = fixval(pos); + if(immediatep(ob)) { return IFALSE; } + hdr = *ob; + if (rawp(hdr) || hdrsize(hdr) < pos) { return IFALSE; } + hdr = hdrsize(hdr); + allocate(hdr, new); + while(p <= hdr) { + new[p] = (pos == p && p) ? val : ob[p]; + p++; + } + return (word) new; +} + +/* system- and io primops */ +static word prim_sys(int op, word a, word b, word c) { + switch(op) { + case 0: { /* 0 fsend fd buff len r → n if wrote n, 0 if busy, False if error (argument or write) */ + int fd = fixval(a); + word *buff = (word *) b; + int wrote, size, len = fixval(c); + if (immediatep(buff)) return IFALSE; + size = (hdrsize(*buff)-1)*W; + if (len > size) return IFALSE; + wrote = write(fd, ((char *)buff)+W, len); + if (wrote > 0) return F(wrote); + if (errno == EAGAIN || errno == EWOULDBLOCK) return F(0); + return IFALSE; } + case 1: { /* 1 = fopen */ + char *path = (char *) a; + int mode = fixval(b); + int val; + struct stat sb; + if (!(allocp(path) && imm_type(*path) == 3)) + return IFALSE; + mode |= O_BINARY | ((mode > 0) ? O_CREAT | O_TRUNC : 0); + val = open(((char *) path) + W, mode,(S_IRUSR|S_IWUSR)); + if (val < 0 || fstat(val, &sb) == -1 || sb.st_mode & S_IFDIR) { + close(val); + return IFALSE; + } + set_blocking(val,0); + return F(val); } + case 2: + return close(fixval(a)) ? IFALSE : ITRUE; + case 3: { /* 3 = sopen port -> False | fd */ + int port = fixval(a); + int s; + int opt = 1; /* TRUE */ + struct sockaddr_in myaddr; + myaddr.sin_family = AF_INET; + myaddr.sin_port = htons(port); + myaddr.sin_addr.s_addr = INADDR_ANY; + s = socket(AF_INET, SOCK_STREAM, 0); +#ifndef WIN32 + if (s < 0) return IFALSE; +#else + if (s == INVALID_SOCKET) return IFALSE; +#endif + if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) \ + || bind(s, (struct sockaddr *) &myaddr, sizeof(myaddr)) != 0 \ + || listen(s, 5) != 0) { + close(s); + return IFALSE; + } + set_blocking(s,0); + return F(s); } + case 4: { /* 4 = accept port -> rval=False|(ip . fd) */ + int sock = fixval(a); + struct sockaddr_in addr; + socklen_t len = sizeof(addr); + int fd; + word *pair; + char *ipa; + fd = accept(sock, (struct sockaddr *)&addr, &len); + if (fd < 0) return IFALSE; + set_blocking(fd,0); + ipa = (char *) &addr.sin_addr; + *fp = make_raw_header(2, TBVEC, 4%W); + bytecopy(ipa, ((char *) fp) + W, 4); + fp[2] = PAIRHDR; + fp[3] = (word) fp; + fp[4] = F(fd); + pair = fp+2; + fp += 5; + return (word)pair; } + case 5: { /* fread fd max -> obj | eof | F (read error) | T (would block) */ + word fd = fixval(a); + word max = fixval(b); + word *res; + int n, nwords = (max/W) + 2; + allocate(nwords, res); +#ifndef WIN32 + n = read(fd, ((char *) res) + W, max); +#else + if (fd == 0) { /* windows stdin in special apparently */ + if(!_isatty(0) || _kbhit()) { /* we don't get hit by kb in pipe */ + n = read(fd, ((char *) res) + W, max); + } else { + n = -1; + errno = EAGAIN; + } + + } else { + n = read(fd, ((char *) res) + W, max); + } +#endif + if (n > 0) { /* got some bytes */ + word read_nwords = (n/W) + ((n%W) ? 2 : 1); + int pads = (read_nwords-1)*W - n; + fp = res + read_nwords; + *res = make_raw_header(read_nwords, TBVEC, pads); + return (word)res; + } + fp = res; + if (n == 0) + return IEOF; + return BOOL(errno == EAGAIN || errno == EWOULDBLOCK); } + case 6: + EXIT(fixval(a)); /* stop the press */ + case 7: /* set memory limit (in mb) */ + max_heap_mb = fixval(a); + return a; + case 8: /* get machine word size (in bytes) */ + return F(W); + case 9: /* get memory limit (in mb) */ + return F(max_heap_mb); + case 10: /* enter linux seccomp mode */ +#ifdef __gnu_linux__ +#ifndef NO_SECCOMP + if (seccompp) /* a true value, but different to signal that we're already in seccomp */ + return INULL; + seccomp_time = 1000 * time(NULL); /* no time calls are allowed from seccomp, so start emulating a time if success */ +#ifdef PR_SET_SECCOMP + if (prctl(PR_SET_SECCOMP,1) != -1) { /* true if no problem going seccomp */ + seccompp = 1; + return ITRUE; + } +#endif +#endif +#endif + return IFALSE; /* seccomp not supported in current repl */ + /* dirops only to be used via exposed functions */ + case 11: { /* sys-opendir path _ _ -> False | dirobjptr */ + char *path = W + (char *) a; /* skip header */ + DIR *dirp = opendir(path); + if(!dirp) return IFALSE; + return fliptag(dirp); } + case 12: { /* sys-readdir dirp _ _ -> bvec | eof | False */ + DIR *dirp = (DIR *)fliptag(a); + word *res; + unsigned int len; + struct dirent *dire = readdir(dirp); + if (!dire) return IEOF; /* eof at end of dir stream */ + len = lenn(dire->d_name, FMAX+1); + if (len == FMAX+1) return IFALSE; /* false for errors, like too long file names */ + res = mkbvec(len, 3); /* make a fake raw string (OS may not use valid UTF-8) */ + bytecopy((char *)&dire->d_name, (char *) (res + 1), len); /* *no* terminating null, this is an owl bvec */ + return (word)res; } + case 13: /* sys-closedir dirp _ _ -> ITRUE */ + closedir((DIR *)fliptag(a)); + return ITRUE; + case 14: { /* set-ticks n _ _ -> old */ + word old = F(slice); + slice = fixval(a); + return old; } + case 15: { /* 0 fsocksend fd buff len r → n if wrote n, 0 if busy, False if error (argument or write) */ + int fd = fixval(a); + word *buff = (word *) b; + int wrote, size, len = fixval(c); + if (immediatep(buff)) return IFALSE; + size = (hdrsize(*buff)-1)*W; + if (len > size) return IFALSE; + wrote = send(fd, ((char *)buff)+W, len, 0); /* <- no MSG_DONTWAIT in win32 */ + if (wrote > 0) return F(wrote); + if (errno == EAGAIN || errno == EWOULDBLOCK) return F(0); + return IFALSE; } + case 16: { /* getenv */ + char *name = (char *)a; + if (!allocp(name)) return IFALSE; + return strp2owl(getenv(name + W)); } + case 17: { /* exec[v] path argl ret */ + char *path = ((char *) a) + W; + int nargs = llen((word *)b); + char **args = malloc((nargs+1) * sizeof(char *)); + char **argp = args; +#ifndef WIN32 + if (args == NULL) + return IFALSE; + while(nargs--) { + *argp++ = ((char *) ((word *) b)[1]) + W; + b = ((word *) b)[2]; + } + *argp = NULL; + set_blocking(0,1); /* try to return stdio to blocking mode */ + set_blocking(1,1); /* warning, other file descriptors will stay in nonblocking mode */ + set_blocking(2,1); + execv(path, args); /* may return -1 and set errno */ + set_blocking(0,0); /* exec failed, back to nonblocking io for owl */ + set_blocking(1,0); + set_blocking(2,0); +#endif + return IFALSE; } + case 20: { /* chdir path res */ + char *path = ((char *)a) + W; + if (chdir(path) < 0) + return IFALSE; + return ITRUE; } +#ifndef WIN32 + case 19: { /* wait _ */ + pid_t pid = (a == IFALSE) ? -1 : fixval(a); + int status; + word *r = (word *) b; + pid = waitpid(pid, &status, WNOHANG|WUNTRACED|WCONTINUED); + if (pid == -1) + return IFALSE; /* error */ + if (pid == 0) + return ITRUE; /* no changes, would block */ + if (WIFEXITED(status)) { + r[1] = F(1); + r[2] = F(WEXITSTATUS(status)); + } else if (WIFSIGNALED(status)) { + r[1] = F(2); + r[2] = F(WTERMSIG(status)); + } else if (WIFSTOPPED(status)) { + r[1] = F(3); + r[2] = F(WSTOPSIG(status)); + } else if (WIFCONTINUED(status)) { + r[1] = F(4); + r[2] = F(1); + } else { + fprintf(stderr, "vm: unexpected process exit status: %d\n", status); + r = (word *)IFALSE; + } + return (word)r; } + case 18: { /* fork ret → #false=failed, fixnum=ok we're in parent process, #true=ok we're in child process */ + pid_t pid = fork(); + if (pid == -1) /* fork failed */ + return IFALSE; + if (pid == 0) /* we're in child, return true */ + return ITRUE; + if ((int)pid > FMAX) + fprintf(stderr, "vm: child pid larger than max fixnum: %d\n", pid); + return F(pid&FMAX); } + case 21: /* kill pid signal → fixnum */ + return (kill(fixval(a), fixval(b)) < 0) ? IFALSE : ITRUE; +#endif + default: + return IFALSE; + } +} + +static word prim_lraw(word wptr, int type, word revp) { + word *lst = (word *) wptr; + int nwords, len = 0, pads; + unsigned char *pos; + word *raw, *ob; + if (revp != IFALSE) { exit(1); } /* <- to be removed */ + ob = lst; + while (allocp(ob) && *ob == PAIRHDR) { + len++; + ob = (word *) ob[2]; + } + if ((word) ob != INULL) return IFALSE; + if (len > FMAX) return IFALSE; + nwords = (len/W) + ((len % W) ? 2 : 1); + allocate(nwords, raw); + pads = (nwords-1)*W - len; /* padding byte count, usually stored to top 3 bits */ + *raw = make_raw_header(nwords, type, pads); + ob = lst; + pos = ((unsigned char *) raw) + W; + while ((word) ob != INULL) { + *pos++ = fixval(ob[1])&255; + ob = (word *) ob[2]; + } + while(pads--) { *pos++ = 0; } /* clear the padding bytes */ + return (word)raw; +} + + +static word prim_mkff(word t, word l, word k, word v, word r) { + word *ob = fp; + ob[1] = k; + ob[2] = v; + if (l == IEMPTY) { + if (r == IEMPTY) { + *ob = make_header(3, t); + fp += 3; + } else { + *ob = make_header(4, t|FFRIGHT); + ob[3] = r; + fp += 4; + } + } else if (r == IEMPTY) { + *ob = make_header(4, t); + ob[3] = l; + fp += 4; + } else { + *ob = make_header(5, t); + ob[3] = l; + ob[4] = r; + fp += 5; + } + return (word) ob; +} + +/* Load heap, convert arguments and start VM */ + +word radamsa_boot(int nargs, char **argv) { + int this, pos, nobjs; + unsigned char *file_heap = NULL; + word *entry; + word *oargs = (word *) INULL; + word *ptrs; + word nwords; + usegc = seccompp = 0; + slice = TICKS; /* default thread slice (n calls per slice) */ + hp = (unsigned char *) &heap; + max_heap_mb = (W == 4) ? 4096 : 65535; /* can be set at runtime */ + memstart = genstart = fp = (word *) realloc(NULL, (INITCELLS + FMAX + MEMPAD)*W); /* at least one argument string always fits */ + if (!memstart) { + fprintf(stderr, "Failed to allocate initial memory\n"); + exit(4); + } + memend = memstart + FMAX + INITCELLS - MEMPAD; + this = nargs-1; + usegc = 1; + while(this >= 0) { /* build an owl string list to oargs at bottom of heap */ + char *str = argv[this]; + char *pos = str; + int pads; + word *tmp; + int len = 0, size; + while(*pos++) len++; + if (len > FMAX) { + puts("owl: command line argument too long"); + exit(1); + } + size = ((len % W) == 0) ? (len/W)+1 : (len/W) + 2; + if ((word)fp + size >= (word)memend) { + oargs = gc(FMAX, oargs); /* oargs points to topmost pair, may move as a result of gc */ + fp = oargs + 3; + } + pads = (size-1)*W - len; + tmp = fp; + fp += size; + *tmp = make_raw_header(size, 3, pads); + pos = ((char *) tmp) + W; + while(*str) *pos++ = *str++; + *fp = PAIRHDR; + fp[1] = (word) tmp; + fp[2] = (word) oargs; + oargs = fp; + fp += 3; + this--; + } + nobjs = count_objs(&nwords); + oargs = gc(nwords+(128*1024), oargs); /* get enough space to load the heap without triggering gc */ + fp = oargs + 3; + ptrs = fp; + fp += nobjs+1; + pos = 0; + while(pos < nobjs) { /* or until fasl stream end mark */ + if (fp >= memend) { + puts("gc needed during heap import\n"); + exit(1); + } + fp = get_obj(ptrs, pos); + pos++; + } + entry = (word *) ptrs[pos-1]; + + + + /* clear the pointers */ + /* fixme, wrong when heap has > 65534 objects */ + ptrs[0] = make_raw_header(nobjs+1,0,0); + if (file_heap != NULL) free((void *) file_heap); + return vm(entry, oargs); +} + +static __thread word R[NR]; + +word vm(word *ob, word *args) { + unsigned char *ip; + int bank = 0; /* ticks deposited at syscall */ + int ticker = slice; /* any initial value ok */ + unsigned short acc = 0; /* no support for >255arg functions */ + int op; /* opcode to execute */ + + word load_imms[] = {F(0), INULL, ITRUE, IFALSE}; /* for ldi and jv */ + usegc = 1; /* enble gc (later have if always evabled) */ + + /* clear blank regs */ + while(acc < NR) { R[acc++] = INULL; } + R[0] = IFALSE; + R[3] = IHALT; + R[4] = (word) args; + acc = 2; /* boot always calls with 2 args*/ + +apply: /* apply something at ob to values in regs, or maybe switch context */ + + if (likely(allocp(ob))) { + word hdr = *ob & 4095; /* cut size out, take just header info */ + if (hdr == make_header(0,TPROC)) { /* proc */ + R[1] = (word) ob; ob = (word *) ob[1]; + } else if (hdr == make_header(0,TCLOS)) { /* clos */ + R[1] = (word) ob; ob = (word *) ob[1]; + R[2] = (word) ob; ob = (word *) ob[1]; + } else if (((hdr>>TPOS)&60) == TFF) { /* low bits have special meaning */ + word *cont = (word *) R[3]; + if (acc == 3) { + R[3] = prim_get(ob, R[4], R[5]); + } else if (acc == 2) { + R[3] = prim_get(ob, R[4], (word) 0); + if (!R[3]) { error(260, ob, R[4]); } + } else { + error(259, ob, INULL); + } + ob = cont; + acc = 1; + goto apply; + } else if (((hdr >> TPOS) & 63) != TBYTECODE) { /* not even code, extend bits later */ + error(259, ob, INULL); + } + if (unlikely(!ticker--)) goto switch_thread; + ip = ((unsigned char *) ob) + W; + goto invoke; + } else if ((word)ob == IEMPTY && acc > 1) { /* ff application: (False key def) -> def */ + ob = (word *) R[3]; /* call cont */ + R[3] = (acc > 2) ? R[5] : IFALSE; /* default arg or false if none */ + acc = 1; + goto apply; + } else if ((word)ob == IHALT) { + /* a tread or mcp is calling the final continuation */ + ob = (word *) R[0]; + if (allocp(ob)) { + R[0] = IFALSE; + breaked = 0; + R[4] = R[3]; + R[3] = F(2); + R[5] = IFALSE; + R[6] = IFALSE; + ticker = 0xffffff; + bank = 0; + acc = 4; + goto apply; + } + return fixval(R[3]); + } /* <- add a way to call the new vm prim table also here? */ + error(257, ob, INULL); /* not callable */ + +switch_thread: /* enter mcp if present */ + if (R[0] == IFALSE) { /* no mcp, ignore */ + ticker = TICKS; + goto apply; + } else { + /* save vm state and enter mcp cont at R0 */ + word *state, pos = 1; + ticker=0xffffff; + bank = 0; + acc = acc + 4; + R[acc] = (word) ob; + allocate(acc, state); + *state = make_header(acc, TTHREAD); + state[acc-1] = R[acc]; + while(pos < acc-1) { + state[pos] = R[pos]; + pos++; + } + ob = (word *) R[0]; + R[0] = IFALSE; /* remove mcp cont */ + /* R3 marks the syscall to perform */ + R[3] = breaked ? ((breaked & 8) ? F(14) : F(10)) : F(1); /* fixme - handle also differnet signals via one handler */ + R[4] = (word) state; + R[5] = F(breaked); + R[6] = IFALSE; + acc = 4; + breaked = 0; + goto apply; + } +invoke: /* nargs and regs ready, maybe gc and execute ob */ + if (((word)fp) + 1024*64 >= ((word) memend)) + //(1) // always gc + { + int p = 0; + *fp = make_header(NR+2, 50); /* hdr r_0 .. r_(NR-1) ob */ + while(p < NR) { fp[p+1] = R[p]; p++; } + fp[p+1] = (word) ob; + fp = gc(1024*64, fp); + ob = (word *) fp[p+1]; + while(--p >= 0) { R[p] = fp[p+1]; } + ip = ((unsigned char *) ob) + W; + } + + op = *ip++; + + if (op) { + main_dispatch: + EXEC; + } else { + op = *ip<<8 | ip[1]; + goto super_dispatch; + } + + op0: op = (*ip << 8) | ip[1]; goto super_dispatch; + op1: {word *ob = (word *)R[*ip]; R[ip[2]] = ob[ip[1]]; NEXT(3);} + op2: OGOTO(*ip,ip[1]); /* fixme, these macros are not used in cgen output anymore*/ + op3: OCLOSE(TCLOS); NEXT(0); + op4: OCLOSE(TPROC); NEXT(0); + op5: /* mov2 from1 to1 from2 to2 */ + R[ip[1]] = R[ip[0]]; + R[ip[3]] = R[ip[2]]; + NEXT(4); + op6: CLOSE1(TCLOS); NEXT(0); + op7: CLOSE1(TPROC); NEXT(0); + op8: /* jlq a b o, extended jump */ + if(R[*ip] == A1) { ip += ip[2] + (ip[3] << 8); } + NEXT(4); + op9: R[ip[1]] = R[*ip]; NEXT(2); + op11: /* unused */ + error(11, IFALSE, IFALSE); + op10: /* unused */ + error(10, IFALSE, IFALSE); + op12: /* jb n */ + ip -= ip[0]; + if (ticker) /* consume thread time */ + ticker--; + NEXT(0); + op13: /* ldi{2bit what} [to] */ + R[*ip++] = load_imms[op>>6]; + NEXT(0); + op14: R[ip[1]] = F(*ip); NEXT(2); + op15: { /* type-byte o r <- actually sixtet */ + word ob = R[*ip++]; + if (allocp(ob)) ob = V(ob); + R[*ip++] = F((ob>>TPOS)&63); + NEXT(0); } + op16: /* jv[which] a o1 a2*/ + /* FIXME, convert this to jump-const comparing to make_immediate(,TCONST) */ + if(R[*ip] == load_imms[op>>6]) { ip += ip[1] + (ip[2] << 8); } + NEXT(3); + op17: /* arity error */ + error(17, ob, F(acc)); + op18: /* goto-code p */ + ob = (word *) R[*ip]; /* needed in opof gc */ + acc = ip[1]; + ip = ((unsigned char *) R[*ip]) + W; + goto invoke; + op19: { /* goto-proc p */ + word *this = (word *) R[*ip]; + R[1] = (word) this; + acc = ip[1]; + ob = (word *) this[1]; + ip = ((unsigned char *) ob) + W; + goto invoke; } + op20: { /* apply */ + int reg, arity; + word *lst; + if (op == 20) { /* normal apply: cont=r3, fn=r4, a0=r5, */ + reg = 4; /* include cont */ + arity = 1; + ob = (word *) R[reg]; + acc -= 3; /* ignore cont, function and stop before last one (the list) */ + while(acc--) { /* move explicitly given arguments down by one to correct positions */ + R[reg] = R[reg+1]; /* copy args down*/ + reg++; + arity++; + } + lst = (word *) R[reg+1]; + } else { /* _sans_cps apply: func=r3, a0=r4, */ + reg = 3; /* include cont */ + arity = 0; + ob = (word *) R[reg]; + acc -= 2; /* ignore function and stop before last one (the list) */ + while(acc--) { /* move explicitly given arguments down by one to correct positions */ + R[reg] = R[reg+1]; /* copy args down*/ + reg++; + arity++; + } + lst = (word *) R[reg+1]; + } + while(allocp(lst) && *lst == PAIRHDR) { /* unwind argument list */ + /* FIXME: unwind only up to last register and add limited rewinding to arity check */ + if (reg > 128) { /* dummy handling for now */ + fprintf(stderr, "TOO LARGE APPLY\n"); + exit(3); + } + R[reg++] = lst[1]; + lst = (word *) lst[2]; + arity++; + } + acc = arity; + goto apply; } + op21: { /* goto-clos p */ + word *this = (word *) R[*ip]; + R[1] = (word) this; + acc = ip[1]; + this = (word *) this[1]; + R[2] = (word) this; + ob = (word *) this[1]; + ip = ((unsigned char *) ob) + W; + goto invoke; } + op22: { /* cast o t r */ + word *ob = (word *) R[*ip]; + word type = fixval(A1) & 63; + A2 = prim_cast(ob, type); + NEXT(3); } + op23: { /* mkt t s f1 .. fs r */ + word t = *ip++; + word s = *ip++ + 1; /* the argument is n-1 to allow making a 256-tuple with 255, and avoid 0-tuples */ + word *ob, p = 0; + allocate(s+1, ob); /* s fields + header */ + *ob = make_header(s+1, t); + while (p < s) { + ob[p+1] = R[ip[p]]; + p++; + } + R[ip[p]] = (word) ob; + NEXT(s+1); } + op24: /* ret val == implicit call r3 with 1 arg */ + ob = (word *) R[3]; + R[3] = R[*ip]; + acc = 1; + goto apply; + op25: { /* jmp-nargs(>=?) a hi lo */ + int needed = *ip; + if (acc == needed) { + if (op & 64) /* add empty extra arg list */ + R[acc + 3] = INULL; + } else if ((op & 64) && acc > needed) { + word tail = INULL; /* todo: no call overflow handling yet */ + while (acc > needed) { + fp[0] = PAIRHDR; + fp[1] = R[acc + 2]; + fp[2] = tail; + tail = (word) fp; + fp += 3; + acc--; + } + R[acc + 3] = tail; + } else { + ip += (ip[1] << 8) | ip[2]; + } + NEXT(3); } + op26: { /* fxqr ah al b qh ql r, b != 0, int32 / int16 -> int32, as fixnums */ + uint64_t a = (((uint64_t) fixval(A0))<>FBITS); + A4 = F(q&FMAX); + A5 = F(a - q*b); + NEXT(6); } + op27: /* syscall cont op arg1 arg2 */ + ob = (word *) R[0]; + R[0] = IFALSE; + R[3] = A1; R[4] = R[*ip]; R[5] = A2; R[6] = A3; + acc = 4; + if (ticker > 10) bank = ticker; /* deposit remaining ticks for return to thread */ + goto apply; + op28: { /* sizeb obj to */ + word ob = R[*ip]; + if (immediatep(ob)) { + A1 = IFALSE; + } else { + word hdr = V(ob); + A1 = (rawp(hdr)) ? F((hdrsize(hdr)-1)*W - ((hdr >> 8) & 7)) : IFALSE; + } + NEXT(2); } + op29: { /* ncons a b r */ + *fp = NUMHDR; + fp[1] = A0; + fp[2] = A1; + A2 = (word) fp; + fp += 3; + NEXT(3); } + op30: { /* ncar a rd */ + word *ob = (word *) R[*ip]; + assert(allocp(ob), ob, 30); + A1 = ob[1]; + NEXT(2); } + op31: { /* ncdr a r */ + word *ob = (word *) R[*ip]; + assert(allocp(ob), ob, 31); + A1 = ob[2]; + NEXT(2); } + op32: { /* bind tuple .. */ + word *tuple = (word *) R[*ip++]; + word hdr, pos = 1, n = *ip++; + assert(allocp(tuple), tuple, 32); + hdr = *tuple; + assert_not((rawp(hdr) || hdrsize(hdr)-1 != n), tuple, 32); + while(n--) { R[*ip++] = tuple[pos++]; } + NEXT(0); } + op33: + error(33, IFALSE, IFALSE); + op34: { /* connect -> fd | False, via an ipv4 tcp stream */ + A2 = prim_connect((word *) A0, A1); /* fixme: remove and put to prim-sys*/ + NEXT(3); } + op35: { /* listuple type size lst to */ + word type = fixval(R[*ip]); + word size = fixval(A1); + word *lst = (word *) A2; + word *ob; + allocate(size+1, ob); + A3 = (word) ob; + *ob++ = make_header(size+1, type); + while(size--) { + assert((allocp(lst) && *lst == PAIRHDR), lst, 35); + *ob++ = lst[1]; + lst = (word *) lst[2]; + } + NEXT(4); } + op36: { /* size o r */ + word *ob = (word *) R[ip[0]]; + R[ip[1]] = (immediatep(ob)) ? IFALSE : F(hdrsize(*ob)-1); + NEXT(2); } + op37: { /* ms r */ +#ifndef WIN32 + if (!seccompp) + usleep(fixval(A0)*1000); +#else + Sleep(fixval(A0)); +#endif + A1 = BOOL(errno == EINTR); + NEXT(2); } + op38: { /* fx+ a b r o, types prechecked, signs ignored, assume fixnumbits+1 fits to machine word */ + word res = fixval(A0) + fixval(A1); + word low = res & FMAX; + A3 = (res & (1 << FBITS)) ? ITRUE : IFALSE; + A2 = F(low); + NEXT(4); } + op39: { /* fx* a b l h */ + uint64_t res = ((uint64_t) ((uint64_t) fixval(R[*ip])) * ((uint64_t) fixval(A1))); + A2 = F(((word)(res&FMAX))); + A3 = F(((word)(res>>FBITS)&FMAX)); + NEXT(4); } + op40: { /* fx- a b r u, args prechecked, signs ignored */ + word r = (fixval(A0)|(1<> a b hi lo */ + uint64_t r = ((uint64_t) fixval(A0)) << (FBITS - fixval(A1)); + A2 = F(r>>FBITS); + A3 = F(r&FMAX); + NEXT(4); } + op59: { /* fx<< a b hi lo */ + uint64_t res = (uint64_t) fixval(R[*ip]) << fixval(A1); + A2 = F(res>>FBITS); + A3 = F(res&FMAX); + NEXT(4); } + op60: /* lraw lst type dir r (fixme, alloc amount testing compiler pass not in place yet!) */ + A3 = prim_lraw(A0, fixval(A1), A2); + NEXT(4); + op61: /* clock */ { /* fixme: sys */ + struct timeval tp; + word *ob; + allocate(6, ob); /* space for 32-bit bignum - [NUM hi [NUM lo null]] */ + ob[0] = ob[3] = NUMHDR; + A0 = (word) (ob + 3); + ob[2] = INULL; + ob[5] = (word) ob; + if (seccompp) { + unsigned long secs = seccomp_time / 1000; + A1 = F(seccomp_time - (secs * 1000)); + ob[1] = F(secs >> FBITS); + ob[4] = F(secs & FMAX); + seccomp_time += ((seccomp_time + 10) > seccomp_time) ? 10 : 0; /* virtual 10ms passes */ + } else { + gettimeofday(&tp, NULL); + A1 = F(tp.tv_usec / 1000); + ob[1] = F(tp.tv_sec >> FBITS); + ob[4] = F(tp.tv_sec & FMAX); + } + NEXT(2); } + op62: /* set-ticker -> old ticker value */ /* fixme: sys */ + A1 = F(ticker & FMAX); + ticker = fixval(A0); + NEXT(2); + op63: { /* sys-prim op arg1 arg2 arg3 r1 */ + A4 = prim_sys(fixval(A0), A1, A2, A3); + NEXT(5); } + +super_dispatch: /* run macro instructions */ + switch(op) { + case 0:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=R[6];R[4]=R[5];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1:if(acc==4){if(R[5]==INULL){R[7]=G(R[1],2);R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}else{R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],5);R[6]=IFALSE;ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 2:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],5);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],6);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 3:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],5);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],6);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 4:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}else{R[4]=G(R[2],5);R[5]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],6);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[2],7);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 5:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 6:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}else{R[4]=G(R[2],5);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],6);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[2],7);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 7:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],5);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}else{R[4]=G(R[2],5);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],6);fp[2]=R[5];R[3]=(word)fp;fp+=3;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 8:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[7]=R[4];R[3]=R[5];R[4]=R[8];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 9:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=F(2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[5]=G(R[2],4);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 10:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[2],5);fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],2);R[4]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[11]=IFALSE;R[12]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 11:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=F(1);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 12:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 13:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[7];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 14:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 15:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 16:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 17:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 18:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[11];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 19:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[3];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=10;R[13]=G(R[2],4);R[6]=IFALSE;R[9]=R[5];R[4]=R[8];R[5]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 20:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=11;R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 21:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);R[10]=G(R[1],10);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[5]=G(R[1],4);R[6]=G(R[1],3);R[14]=G(R[1],2);R[15]=R[4];R[8]=R[3];R[4]=R[7];R[3]=R[11];R[7]=R[14];ob=(word *)R[15];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 22:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[12];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 23:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[13]=G(R[2],4);R[5]=G(R[2],5);R[9]=R[4];R[6]=R[3];R[3]=R[12];R[4]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 24:if(acc==1){R[4]=G(R[1],8);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[4];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=9;R[7]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 25:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],7);R[6]=G(R[1],8);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;R[8]=G(R[2],2);R[4]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);R[12]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[7];fp[5]=R[12];fp[4]=R[11];fp[3]=R[10];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);R[6]=IFALSE;ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 26:if(acc==7){R[10]=G(R[2],2);R[11]=G(R[1],2);R[12]=G(R[1],3);R[13]=G(R[1],4);*fp=make_header(12,TCLOS);fp[1]=G(R[2],3);fp[11]=R[3];fp[10]=R[9];fp[9]=R[6];fp[8]=R[8];fp[7]=R[13];fp[6]=R[5];fp[5]=R[7];fp[4]=R[12];fp[3]=R[4];fp[2]=R[11];R[3]=(word)fp;fp+=12;R[4]=R[11];ob=(word *)R[10];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 27:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);R[11]=G(R[1],10);R[12]=G(R[1],11);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[13]=(word)fp;fp+=11;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[13];acc=1;}else{R[14]=G(R[2],2);R[4]=G(R[1],2);R[5]=R[9];R[3]=R[13];ob=(word *)R[14];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 28:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],10);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);R[13]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[13];fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[14]=(word)fp;fp+=10;R[7]=R[4];R[3]=R[5];R[4]=R[14];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],6);R[5]=G(R[1],10);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[2],5);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 29:if(acc==1){R[4]=G(R[1],2);R[3]=F(0);ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 30:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[11];fp[7]=R[3];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 31:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=11;R[15]=G(R[2],4);R[9]=R[6];R[4]=R[5];R[6]=R[10];R[5]=R[15];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 32:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);*fp=make_header(10,TCLOS);fp[1]=G(R[2],2);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[13]=(word)fp;fp+=10;R[7]=R[4];R[4]=R[3];R[3]=R[13];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 33:if(acc==3){R[6]=G(R[1],7);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[10];fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=G(R[1],4);R[13]=G(R[1],3);R[14]=G(R[1],2);R[10]=R[6];R[7]=R[5];R[5]=R[13];R[6]=R[14];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 34:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],6);R[13]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[13];fp[8]=R[12];fp[7]=R[3];fp[6]=R[4];fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=10;R[15]=G(R[2],4);R[4]=R[5];R[5]=R[15];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 35:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[7]=R[4];R[4]=R[3];R[3]=R[12];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 36:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],2);R[5]=F(1);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 37:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[5]=G(R[2],4);R[6]=G(R[2],5);R[13]=R[4];R[4]=R[10];ob=(word *)R[13];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 38:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=F(1);R[12]=R[6];R[13]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[9];R[9]=R[4];R[4]=R[12];R[3]=R[13];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 39:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[10]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 40:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=F(1);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=G(R[2],4);R[11]=R[4];R[6]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 41:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[9]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[8];R[3]=(word)fp;fp+=3;ob=(word *)R[9];acc=1;}else{ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 42:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=INULL;R[10]=R[6];R[6]=R[7];R[7]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 43:if(acc==5){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);if(R[8]==IFALSE){R[9]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=G(R[1],4);R[5]=G(R[1],5);ob=(word *)R[9];acc=3;}else{R[9]=G(R[5],1);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[1],7);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=R[9];ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 44:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],7);R[3]=G(R[1],6);R[4]=G(R[1],5);R[6]=R[8];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=G(R[1],3);R[5]=G(R[2],4);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 45:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 46:if(acc==4){*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=6;if(R[5]==IFALSE){R[3]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[3]=G(R[1],3);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 47:if(acc==1){R[4]=G(R[1],3);if(R[4]==IFALSE){R[5]=G(R[1],2);if(R[5]==IFALSE){R[6]=G(R[1],4);R[3]=G(R[2],2);ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],4);ob=(word *)R[6];acc=1;}}else{R[5]=G(R[2],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[9]=G(R[2],5);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 48:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[8]=G(R[2],2);R[4]=G(R[1],2);R[3]=R[7];ob=(word *)R[8];acc=2;}else{R[3]=G(R[2],3);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 49:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=G(R[2],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],2);R[5]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 50:if(acc==2){R[5]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],7);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=5;R[7]=G(R[2],2);if(R[4]==R[7]){R[8]=G(R[1],2);R[9]=G(R[2],3);if(R[8]==R[9]){R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[10]=G(R[2],4);R[3]=R[6];R[4]=R[8];ob=(word *)R[10];acc=2;}}else{R[8]=G(R[2],5);R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],6);fp[3]=R[6];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 51:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 52:if(acc==2){R[5]=G(R[1],2);if(R[4]==R[5]){R[6]=F(42);ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[5]=G(R[1],5);R[9]=IFALSE;R[10]=R[6];R[3]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 53:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[6]=IFALSE;R[10]=R[4];R[4]=R[5];R[3]=R[7];R[5]=R[8];ob=(word *)R[10];acc=4;}else{R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],7);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[8]=G(R[2],5);R[3]=G(R[1],3);R[4]=G(R[2],6);ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 54:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],6);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[7]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[3]=(word)fp;fp+=3;R[5]=G(R[2],4);R[6]=G(R[2],5);ob=(word *)R[7];acc=4;}else{ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 55:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],2);R[5]=G(R[2],4);R[9]=F(0);R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 56:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[12]=G(R[2],2);R[3]=G(R[1],3);R[4]=G(R[2],3);ob=(word *)R[12];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 57:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[2],3);R[7]=INULL;R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 58:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[8];acc=1;}else{R[9]=G(R[2],3);R[4]=G(R[2],4);R[3]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 59:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[6];fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=6;R[8]=G(R[1],2);if(R[8]==INULL){R[3]=G(R[2],2);ob=(word *)R[7];acc=1;}else{R[9]=F(32);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=F(44);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 60:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 61:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(58);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[8]=G(R[2],2);R[3]=G(R[1],3);R[4]=G(R[1],2);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 62:if(acc==2){R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[3]=R[6];R[6]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 63:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],4);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 64:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){assert(pairp(R[4]),R[4],1053);R[4]=G(R[4],2);R[10]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[8];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=2;}else{ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 65:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],4);R[5]=G(R[2],4);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],5);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],6);fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[10]=INULL;R[4]=R[5];R[5]=R[10];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 66:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[2],5);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 67:if(acc==2){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=F(3);R[8]=prim_ref(R[4],R[7]);R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[12];R[13]=(word)fp;fp+=3;R[14]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[13];R[4]=(word)fp;fp+=3;R[16]=G(R[1],2);ob=(word *)R[16];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 68:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 69:if(acc==1){R[4]=G(R[1],2);ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 70:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 71:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[5]=F(10);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 72:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 73:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 74:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[2],3);R[7]=F(0);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 75:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(8);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 76:if(acc==1){R[4]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=4;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[6]=G(R[2],2);R[7]=F(0);R[4]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 77:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=R[5];R[3]=R[6];R[6]=R[4];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 78:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=F(10);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],3);R[3]=G(R[2],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 79:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[5]=F(0);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 80:if(acc==3){R[6]=G(R[1],2);R[7]=INULL;R[10]=R[7];R[7]=R[6];R[6]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 81:if(acc==5){if(R[5]==INULL){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[1],5);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=F(10);ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 82:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[5],1);R[8]=G(R[2],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[3];fp[4]=R[6];fp[3]=R[9];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[13]=F(2);R[5]=R[4];R[4]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 83:if(acc==1){R[4]=G(R[1],2);R[5]=F(1);R[6]=prim_set(R[4],R[5],R[3]);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],7);R[3]=G(R[1],6);R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 84:if(acc==4){R[7]=G(R[1],2);R[8]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[6];fp[3]=R[4];fp[2]=R[7];R[9]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[9];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 85:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[4];fp[6]=R[9];fp[5]=R[3];fp[4]=R[5];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=9;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 86:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);if(R[4]==INULL){R[5]=G(R[1],8);R[6]=G(R[1],6);R[7]=G(R[1],3);R[8]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);ob=(word *)R[5];acc=3;}else{R[5]=G(R[1],5);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 87:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=INULL;R[6]=R[3];R[7]=R[8];R[3]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 88:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],4);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[3];fp[4]=R[6];fp[3]=R[10];fp[2]=R[9];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[8];ob=(word *)R[5];acc=3;}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);{word *ob=(word *)R[8];word hdr;assert(allocp(R[8]),R[8],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];R[12]=ob[4];}R[13]=G(R[1],3);R[14]=G(R[1],4);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[7];fp[9]=R[3];fp[8]=R[14];fp[7]=R[4];fp[6]=R[13];fp[5]=R[5];fp[4]=R[10];fp[3]=R[12];fp[2]=R[9];R[3]=(word)fp;fp+=11;R[16]=G(R[1],2);R[4]=R[6];R[5]=R[13];R[6]=R[16];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 89:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],6);R[13]=G(R[1],7);R[14]=G(R[1],8);R[15]=G(R[1],9);R[16]=G(R[1],10);*fp=make_header(14,TCLOS);fp[1]=G(R[2],3);fp[13]=R[16];fp[12]=R[15];fp[11]=R[4];fp[10]=R[5];fp[9]=R[6];fp[8]=R[14];fp[7]=R[13];fp[6]=R[12];fp[5]=R[11];fp[4]=R[10];fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=14;R[4]=G(R[1],2);R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 90:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);*fp=make_header(5,2);fp[1]=R[3];fp[2]=R[4];fp[3]=R[5];fp[4]=R[6];R[7]=(word)fp;fp+=5;R[8]=G(R[1],5);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[2],2);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);R[4]=G(R[1],10);R[16]=G(R[1],11);R[17]=G(R[1],12);R[18]=G(R[1],13);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[18];fp[9]=R[17];fp[8]=R[9];fp[7]=R[16];fp[6]=R[4];fp[5]=R[14];fp[4]=R[13];fp[3]=R[12];fp[2]=R[11];R[3]=(word)fp;fp+=11;ob=(word *)R[10];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 91:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);R[11]=G(R[1],10);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[12]=(word)fp;fp+=10;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[12];acc=1;}else{R[13]=G(R[1],2);assert(pairp(R[13]),R[13],1052);R[4]=G(R[13],1);assert(pairp(R[7]),R[7],1052);R[5]=G(R[7],1);R[16]=G(R[2],2);R[3]=R[12];ob=(word *)R[16];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 92:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],7);ob=(word *)R[6];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],9);R[7]=G(R[1],8);R[8]=G(R[1],7);R[9]=G(R[1],6);R[4]=R[5];R[3]=R[7];R[7]=R[6];R[5]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 93:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[5]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 94:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 95:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[7]=(word)fp;fp+=3;R[8]=G(R[1],4);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 96:if(acc==3){R[6]=F(1);R[7]=prim_ref(R[5],R[6]);R[8]=F(2);R[9]=prim_ref(R[5],R[8]);R[10]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[7];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 97:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[4]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 98:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[2],4);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 99:if(acc==3){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 100:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(10);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 101:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 102:if(acc==2){if(R[4]==IFALSE){R[5]=IFALSE;ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 103:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=F(10);*fp=make_header(5,2);fp[1]=R[7];fp[2]=R[5];fp[3]=R[3];fp[4]=R[6];R[3]=(word)fp;fp+=5;R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 104:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],4);R[8]=R[5];R[5]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 105:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[5]=(word)fp;fp+=3;R[9]=G(R[2],2);R[10]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[10];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 106:if(acc==1){R[4]=IFALSE;if(R[4]==IFALSE){R[5]=G(R[1],2);R[3]=R[4];ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],2);R[3]=R[4];ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 107:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[10]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 108:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],7);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[2],3);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],3);R[5]=G(R[1],2);R[12]=R[4];R[6]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 109:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 110:if(acc==5){R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[5];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 111:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[4];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 112:if(acc==1){R[4]=F(1);R[5]=prim_ref(R[3],R[4]);R[6]=G(R[2],2);if(R[5]==R[6]){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}R[9]=G(R[2],3);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[12];fp[3]=R[11];fp[2]=R[10];R[3]=(word)fp;fp+=5;R[4]=G(R[1],4);R[5]=R[8];ob=(word *)R[9];acc=3;}else{R[7]=G(R[2],5);if(R[5]==R[7]){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[7]=G(R[1],3);R[3]=G(R[1],7);R[4]=G(R[1],4);R[5]=G(R[1],6);R[6]=G(R[1],2);ob=(word *)R[7];acc=5;}else{R[8]=G(R[2],6);if(R[5]==R[8]){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];R[12]=ob[4];}R[13]=G(R[2],3);R[14]=G(R[1],5);R[15]=G(R[1],6);R[16]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],7);fp[6]=R[16];fp[5]=R[15];fp[4]=R[14];fp[3]=R[10];fp[2]=R[12];R[3]=(word)fp;fp+=7;R[4]=G(R[1],4);R[5]=R[11];ob=(word *)R[13];acc=3;}else{R[9]=G(R[2],8);R[10]=G(R[1],7);R[4]=G(R[2],9);R[5]=R[3];R[3]=R[10];ob=(word *)R[9];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 113:if(acc==2){R[5]=G(R[2],4);R[6]=G(R[1],3);R[7]=G(R[1],2);*fp=make_header(5,2);fp[1]=R[5];fp[2]=R[6];fp[3]=R[4];fp[4]=R[7];R[6]=(word)fp;fp+=5;R[9]=G(R[2],2);R[10]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[10];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=G(R[1],5);R[5]=G(R[1],4);ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 114:if(acc==2){R[5]=G(R[2],4);*fp=make_header(3,2);fp[1]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=G(R[1],2);ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 115:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 116:if(acc==2){if(R[4]==F(0)){R[5]=G(R[2],2);R[4]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[5];acc=2;}else{R[5]=F(1);if(R[4]==R[5]){R[6]=G(R[2],2);R[4]=G(R[1],2);R[8]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[8];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{R[6]=F(2);if(R[4]==R[6]){R[7]=G(R[2],5);R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],6);fp[3]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=4;R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{R[7]=F(0);R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[2],7);R[11]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],8);fp[3]=R[11];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=G(R[1],2);ob=(word *)R[10];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 117:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 118:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[9];R[6]=(word)fp;fp+=3;R[9]=R[5];R[5]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 119:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[4]=R[3];R[3]=R[8];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 120:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[9]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[4];R[6]=(word)fp;fp+=3;R[11]=R[5];R[3]=R[7];R[4]=R[8];R[5]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 121:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 122:if(acc==4){if(R[4]==F(0)){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=F(1);{word r=(fixval(R[4])|(1< */ + case 123:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(11);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 124:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],2);R[4]=G(R[2],2);ob=(word *)R[5];acc=2;}else{R[5]=F(1);if(R[4]==R[5]){R[6]=G(R[1],2);R[4]=G(R[2],3);ob=(word *)R[6];acc=2;}else{R[6]=F(2);if(R[4]==R[6]){R[7]=G(R[1],2);R[4]=G(R[2],4);ob=(word *)R[7];acc=2;}else{R[7]=F(3);if(R[4]==R[7]){R[8]=G(R[1],2);R[4]=G(R[2],5);ob=(word *)R[8];acc=2;}else{R[8]=F(4);if(R[4]==R[8]){R[9]=G(R[1],2);R[4]=G(R[2],6);ob=(word *)R[9];acc=2;}else{R[9]=F(5);if(R[4]==R[9]){R[10]=G(R[1],2);R[4]=G(R[2],7);ob=(word *)R[10];acc=2;}else{R[10]=F(6);if(R[4]==R[10]){R[11]=G(R[1],2);R[4]=G(R[2],8);ob=(word *)R[11];acc=2;}else{R[11]=F(7);if(R[4]==R[11]){R[12]=G(R[1],2);R[4]=G(R[2],9);ob=(word *)R[12];acc=2;}else{R[12]=F(8);if(R[4]==R[12]){R[13]=G(R[1],2);R[4]=G(R[2],10);ob=(word *)R[13];acc=2;}else{R[13]=F(9);if(R[4]==R[13]){R[14]=G(R[1],2);R[4]=G(R[2],11);ob=(word *)R[14];acc=2;}else{R[14]=G(R[2],12);R[15]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],13);fp[2]=R[15];R[16]=(word)fp;fp+=3;R[5]=G(R[2],14);R[4]=R[3];R[3]=R[16];ob=(word *)R[14];acc=3;}}}}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 125:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 126:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[4],2);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[3];fp[5]=R[7];fp[4]=R[6];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 127:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=G(R[1],2);ob=(word *)R[8];acc=1;}else{R[9]=G(R[1],2);assert(pairp(R[9]),R[9],1053);R[3]=G(R[9],2);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 128:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 129:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(20);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 130:if(acc==2){R[5]=G(R[2],4);R[6]=G(R[2],2);R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[5];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[5]=F(1);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 131:if(acc==5){if(R[5]==F(0)){R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 132:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[11]=F(1);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 133:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=INULL;R[10]=R[6];R[11]=R[5];R[5]=R[3];R[6]=R[7];R[7]=R[4];R[4]=R[10];R[3]=R[11];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 134:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(8);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 135:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[2],4);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 136:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=F(1);R[7]=prim_ref(R[5],R[6]);R[8]=G(R[2],2);if(R[8]==R[7]){R[9]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[9];acc=1;}else{R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 137:if(acc==3){R[6]=F(1);R[7]=prim_ref(R[4],R[6]);R[8]=G(R[1],2);if(R[7]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];}R[11]=G(R[1],3);R[4]=R[10];ob=(word *)R[11];acc=3;}else{R[9]=G(R[1],4);if(R[7]==R[9]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];R[12]=ob[3];R[13]=ob[4];}*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[15]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[4]=R[12];ob=(word *)R[15];acc=3;}else{R[10]=G(R[1],6);if(R[7]==R[10]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];}R[13]=G(R[1],3);R[4]=R[12];ob=(word *)R[13];acc=3;}else{R[11]=G(R[1],7);R[12]=G(R[1],8);R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 138:if(acc==2){R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TPROC);fp[1]=G(R[1],2);fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=5;*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[7];R[9]=(word)fp;fp+=5;*fp=make_header(5,TPROC);fp[1]=G(R[1],4);fp[4]=R[7];fp[3]=R[5];fp[2]=R[6];R[10]=(word)fp;fp+=5;R[5]=INULL;R[6]=R[5];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 139:if(acc==7){if(R[4]==INULL){if(R[5]==INULL){R[10]=G(R[1],2);R[4]=R[6];ob=(word *)R[10];acc=2;}else{R[10]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=G(R[1],5);ob=(word *)R[10];acc=4;}}else{R[10]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[1],7);fp[8]=R[8];fp[7]=R[3];fp[6]=R[4];fp[5]=R[7];fp[4]=R[9];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 140:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],4);R[10]=G(R[1],7);R[6]=G(R[1],3);R[7]=G(R[1],5);R[13]=G(R[1],8);R[4]=R[5];R[5]=R[8];R[3]=R[10];R[8]=R[13];ob=(word *)R[9];acc=7;}else{R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[1],8);R[6]=G(R[1],7);R[7]=G(R[1],6);R[8]=INULL;R[9]=G(R[1],3);R[10]=G(R[1],5);R[11]=G(R[1],4);R[12]=R[8];R[8]=R[5];R[3]=R[6];R[4]=R[7];R[6]=R[9];R[7]=R[10];R[9]=R[11];R[5]=R[12];ob=(word *)R[8];acc=7;}else{R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[12]=G(R[2],4);R[6]=G(R[1],3);R[9]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[9];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 141:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=INULL;R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[5];R[5]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[12];ob=(word *)R[8];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 142:if(acc==7){if(R[4]==INULL){R[10]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=G(R[1],4);ob=(word *)R[10];acc=4;}else{assert(pairp(R[4]),R[4],1052);R[10]=G(R[4],1);R[11]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[1],6);fp[8]=R[7];fp[7]=R[3];fp[6]=R[6];fp[5]=R[8];fp[4]=R[9];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[10];ob=(word *)R[11];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 143:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],8);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[6];acc=2;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[4],1);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[1],8);R[11]=G(R[1],7);R[12]=INULL;R[13]=G(R[1],6);R[14]=G(R[1],5);R[15]=G(R[1],4);R[4]=R[5];R[5]=R[6];R[6]=R[3];R[8]=R[9];R[3]=R[11];R[7]=R[12];R[9]=R[13];R[11]=R[14];R[12]=R[15];ob=(word *)R[10];acc=10;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 144:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],8);R[6]=G(R[1],5);R[7]=G(R[1],2);R[8]=G(R[1],7);R[9]=G(R[1],4);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],6);R[9]=R[4];R[4]=R[11];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],8);R[10]=G(R[1],7);R[6]=G(R[1],6);R[7]=G(R[1],5);R[13]=G(R[1],4);R[4]=R[5];R[5]=R[8];R[8]=R[9];R[3]=R[10];R[9]=R[13];ob=(word *)R[8];acc=7;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 145:if(acc==10){if(R[4]==INULL){R[13]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;R[4]=R[7];R[5]=R[8];ob=(word *)R[13];acc=3;}else{assert(pairp(R[4]),R[4],1052);R[13]=G(R[4],1);if(R[13]==R[6]){assert(pairp(R[8]),R[8],1053);R[14]=G(R[8],2);R[15]=G(R[1],4);*fp=make_header(11,TCLOS);fp[1]=G(R[1],5);fp[10]=R[12];fp[9]=R[3];fp[8]=R[10];fp[7]=R[11];fp[6]=R[9];fp[5]=R[14];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=11;R[4]=R[7];ob=(word *)R[15];acc=2;}else{R[14]=F(92);if(R[13]==R[14]){R[15]=G(R[4],2);if(R[15]==INULL){R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[7];R[7]=(word)fp;fp+=3;ob=(word *)R[10];acc=10;}else{R[16]=G(R[1],6);*fp=make_header(12,TCLOS);fp[1]=G(R[1],7);fp[11]=R[10];fp[10]=R[3];fp[9]=R[5];fp[8]=R[6];fp[7]=R[8];fp[6]=R[9];fp[5]=R[11];fp[4]=R[12];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=12;ob=(word *)R[16];acc=2;}}else{R[15]=G(R[1],8);*fp=make_header(12,TCLOS);fp[1]=G(R[1],9);fp[11]=R[10];fp[10]=R[3];fp[9]=R[5];fp[8]=R[6];fp[7]=R[8];fp[6]=R[9];fp[5]=R[11];fp[4]=R[12];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=12;R[4]=R[13];ob=(word *)R[15];acc=2;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 146:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],11);R[8]=G(R[1],2);R[9]=G(R[1],10);R[10]=G(R[1],4);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],3);R[5]=G(R[1],7);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],11);R[10]=G(R[1],10);R[11]=G(R[1],9);R[12]=G(R[1],8);R[13]=G(R[1],7);R[14]=G(R[1],6);R[15]=G(R[1],5);R[16]=G(R[1],4);R[4]=R[5];R[7]=R[8];R[3]=R[10];R[10]=R[9];R[5]=R[11];R[6]=R[12];R[8]=R[13];R[9]=R[14];R[11]=R[15];R[12]=R[16];ob=(word *)R[10];acc=10;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 147:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[2],4);R[6]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 148:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=INULL;R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[5];R[5]=R[7];R[7]=R[8];R[8]=R[9];R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 149:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);R[13]=G(R[1],10);R[14]=G(R[1],11);*fp=make_header(12,TCLOS);fp[1]=G(R[2],3);fp[11]=R[14];fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[15]=(word)fp;fp+=12;R[7]=R[4];R[4]=R[3];R[3]=R[15];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 150:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],11);R[10]=G(R[1],10);R[11]=G(R[1],9);R[12]=G(R[1],8);R[13]=G(R[1],7);R[14]=G(R[1],6);R[15]=G(R[1],5);R[16]=G(R[1],4);R[4]=R[5];R[7]=R[8];R[3]=R[10];R[10]=R[9];R[5]=R[11];R[6]=R[12];R[8]=R[13];R[9]=R[14];R[11]=R[15];R[12]=R[16];ob=(word *)R[10];acc=10;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);R[13]=G(R[1],10);R[14]=G(R[1],11);*fp=make_header(12,TCLOS);fp[1]=G(R[2],3);fp[11]=R[14];fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=12;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 151:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);R[13]=G(R[1],11);*fp=make_header(12,TPROC);fp[1]=G(R[2],3);fp[11]=R[13];fp[10]=R[12];fp[9]=R[3];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=12;R[15]=G(R[1],2);R[7]=R[4];R[4]=R[15];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 152:if(acc==1){R[4]=F(92);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],11);R[9]=G(R[1],10);R[10]=G(R[1],9);R[11]=G(R[1],8);R[12]=G(R[1],7);R[13]=G(R[1],6);R[14]=G(R[1],5);R[15]=G(R[1],4);R[16]=G(R[1],3);R[4]=R[10];R[10]=R[8];R[3]=R[9];R[5]=R[11];R[6]=R[12];R[8]=R[13];R[9]=R[14];R[11]=R[15];R[12]=R[16];ob=(word *)R[10];acc=10;}else{{error(17,ob,F(acc));}}break; /* # */ + case 153:if(acc==1){R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);*fp=make_header(5,2);fp[1]=R[4];fp[2]=R[5];fp[3]=R[3];fp[4]=R[6];R[7]=(word)fp;fp+=5;R[8]=G(R[1],5);if(R[8]==INULL){R[9]=G(R[1],4);assert(pairp(R[9]),R[9],1053);R[10]=G(R[9],2);R[11]=G(R[1],6);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[11];R[6]=(word)fp;fp+=3;R[9]=G(R[1],10);R[3]=G(R[1],9);R[5]=INULL;R[7]=G(R[1],8);R[8]=G(R[1],7);R[4]=R[10];ob=(word *)R[9];acc=7;}else{R[9]=G(R[1],4);assert(pairp(R[9]),R[9],1053);R[10]=G(R[9],2);R[11]=G(R[2],2);R[12]=G(R[1],6);R[13]=G(R[1],7);R[14]=G(R[1],8);R[15]=G(R[1],9);R[16]=G(R[1],10);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[16];fp[7]=R[15];fp[6]=R[10];fp[5]=R[14];fp[4]=R[13];fp[3]=R[7];fp[2]=R[12];R[3]=(word)fp;fp+=9;R[4]=R[8];ob=(word *)R[11];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 154:if(acc==1){R[4]=G(R[2],2);*fp=make_header(3,2);fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[1],8);R[3]=G(R[1],7);R[4]=G(R[1],6);R[5]=INULL;R[7]=G(R[1],5);R[8]=G(R[1],4);R[6]=R[9];R[9]=R[10];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 155:if(acc==4){R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[8];R[8]=R[9];R[9]=R[7];R[7]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 156:if(acc==4){R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[8];R[8]=R[7];R[7]=R[12];ob=(word *)R[8];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 157:if(acc==7){R[10]=G(R[1],4);R[11]=G(R[1],3);R[12]=G(R[1],2);ob=(word *)R[10];acc=10;}else{{error(17,ob,F(acc));}}break; /* # */ + case 158:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 159:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 160:if(acc==2){R[5]=G(R[1],2);R[6]=F(6);R[9]=R[6];R[6]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 161:if(acc==4){if(R[4]==INULL){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==F(0)){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[7];ob=(word *)R[8];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 162:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 163:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=F(9);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 164:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(126);R[9]=R[4];R[4]=R[6];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 165:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(31);R[9]=R[4];R[4]=R[6];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 166:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=F(9);if(R[4]==R[5]){R[6]=G(R[1],2);R[3]=ITRUE;ob=(word *)R[6];acc=1;}else{R[6]=F(10);if(R[4]==R[6]){R[7]=G(R[1],2);R[3]=ITRUE;ob=(word *)R[7];acc=1;}else{R[7]=F(13);if(R[4]==R[7]){R[8]=G(R[1],2);R[3]=ITRUE;ob=(word *)R[8];acc=1;}else{R[8]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[8];acc=1;}}}}else{R[4]=G(R[1],2);R[3]=ITRUE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 167:if(acc==2){R[5]=F(39);if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[6]=F(34);if(R[4]==R[6]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 168:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[4];fp[7]=R[5];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[12]=(word)fp;fp+=9;R[5]=F(10);R[4]=R[3];R[3]=R[12];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 169:if(acc==2){R[5]=G(R[1],8);if(R[5]==IFALSE){R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[7];R[8]=(word)fp;fp+=3;R[5]=G(R[1],3);R[10]=G(R[1],4);R[7]=G(R[2],3);R[12]=R[6];R[4]=R[3];R[3]=R[8];R[6]=R[10];ob=(word *)R[12];acc=5;}else{R[6]=G(R[2],4);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[10];fp[5]=R[9];fp[4]=R[3];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[12]=G(R[1],2);R[13]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[5];fp[3]=R[13];fp[2]=R[4];R[14]=(word)fp;fp+=5;R[9]=R[6];R[4]=R[12];R[5]=R[13];R[6]=R[14];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 170:if(acc==2){R[5]=G(R[2],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[5];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 171:if(acc==4){if(R[5]==INULL){R[5]=IFALSE;R[8]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[8];acc=3;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 172:if(acc==2){if(R[4]==IFALSE){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[4]=R[3];R[5]=R[6];R[6]=R[7];R[3]=R[8];ob=(word *)R[6];acc=4;}else{R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[1],4);R[5]=R[4];R[4]=R[6];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 173:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=IFALSE;R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 174:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[4];fp[4]=R[5];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[5]=F(2);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 175:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[6];fp[3]=R[7];fp[2]=R[8];R[10]=(word)fp;fp+=6;R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[10];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],2);R[3]=G(R[1],5);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 176:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[11]=F(1);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 177:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[6]=R[3];R[3]=R[7];R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 178:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 179:if(acc==2){R[5]=INULL;ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 180:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[11]=(word)fp;fp+=9;R[5]=F(2);R[8]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 181:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[5];fp[7]=R[11];fp[6]=R[10];fp[5]=R[3];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=9;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 182:if(acc==1){R[4]=G(R[1],8);*fp=make_header(3,TPROC);fp[1]=G(R[2],5);fp[2]=R[3];R[5]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[4];R[7]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[10];R[4]=(word)fp;fp+=3;R[12]=G(R[2],2);R[13]=G(R[1],2);R[14]=G(R[1],3);R[15]=G(R[1],4);R[16]=G(R[1],5);R[17]=G(R[1],6);R[18]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[18];fp[6]=R[17];fp[5]=R[16];fp[4]=R[15];fp[3]=R[14];fp[2]=R[13];R[3]=(word)fp;fp+=8;ob=(word *)R[12];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 183:if(acc==5){R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[4]=(word)fp;fp+=6;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 184:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;assert(pairp(R[6]),R[6],1052);R[4]=G(R[6],1);R[11]=G(R[2],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[8];fp[6]=R[3];fp[5]=R[5];fp[4]=R[6];fp[3]=R[7];fp[2]=R[9];R[3]=(word)fp;fp+=8;ob=(word *)R[11];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 185:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 186:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[10]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 187:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[11]=(word)fp;fp+=9;R[7]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 188:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[13]=F(2);R[8]=R[4];R[4]=R[5];R[5]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 189:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=G(R[1],2);R[6]=F(2);R[9]=R[4];R[4]=R[11];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],7);R[5]=G(R[1],8);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[2],5);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 190:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[11]=(word)fp;fp+=7;R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 191:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[3];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=9;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 192:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[9]=R[4];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 193:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[7];fp[6]=R[4];fp[5]=R[5];fp[4]=R[6];fp[3]=R[10];fp[2]=R[9];R[4]=(word)fp;fp+=8;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 194:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[10]=G(R[2],2);R[11]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[8];fp[6]=R[3];fp[5]=R[6];fp[4]=R[11];fp[3]=R[7];fp[2]=R[9];R[3]=(word)fp;fp+=8;R[13]=G(R[1],2);R[4]=R[5];R[5]=R[13];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 195:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=G(R[2],3);R[11]=R[4];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];R[8]=R[10];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 196:if(acc==1){R[4]=G(R[1],5);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[3];fp[5]=R[4];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 197:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 198:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[10]=(word)fp;fp+=8;R[11]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 199:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[11]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 200:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[5]=INULL;R[8]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 201:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[11]=(word)fp;fp+=6;R[4]=R[3];R[3]=R[11];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 202:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=F(1);R[10]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 203:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 204:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=G(R[1],3);R[4]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 205:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 206:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=INULL;R[9]=R[6];R[6]=R[4];R[3]=R[5];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);R[3]=G(R[1],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 207:if(acc==4){if(R[4]==INULL){R[7]=G(R[1],2);R[4]=R[5];ob=(word *)R[7];acc=2;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],5);R[6]=IFALSE;R[5]=R[7];ob=(word *)R[8];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 208:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[6]=G(R[1],5);R[3]=G(R[1],4);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[5];R[11]=(word)fp;fp+=6;R[12]=INULL;R[5]=R[3];R[4]=R[6];R[3]=R[11];R[6]=R[12];ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 209:if(acc==2){if(R[4]==IFALSE){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 210:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],4);R[4]=R[3];R[5]=R[6];R[3]=R[8];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 211:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 212:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 213:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=G(R[1],4);R[4]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],2);R[11]=IFALSE;R[12]=R[4];R[4]=R[6];R[6]=R[11];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 214:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[6];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[9]=(word)fp;fp+=6;R[7]=R[3];R[4]=R[5];R[3]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 215:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[9]=G(R[1],3);R[4]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 216:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[3];fp[5]=R[7];fp[4]=R[5];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 217:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);if(R[5]==R[6]){R[7]=G(R[1],3);R[3]=G(R[1],6);ob=(word *)R[7];acc=2;}else{R[7]=G(R[4],1);R[8]=G(R[1],5);R[9]=G(R[1],3);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[10];fp[5]=R[8];fp[4]=R[6];fp[3]=R[9];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[5]=R[6];R[4]=R[7];R[7]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 218:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[3];R[8]=(word)fp;fp+=4;R[9]=G(R[1],4);R[10]=G(R[1],3);R[4]=R[5];R[7]=R[6];R[3]=R[8];R[5]=R[9];R[6]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 219:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=IFALSE;R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[8]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 220:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[6];fp[5]=R[3];fp[4]=R[7];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 221:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],6);R[7]=G(R[1],5);R[8]=G(R[1],3);R[4]=R[5];R[3]=R[7];R[5]=R[8];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],6);R[10]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[9];fp[3]=R[10];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=R[6];R[5]=R[8];R[6]=R[9];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 222:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=R[6];ob=(word *)R[8];acc=2;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}if(R[8]==R[5]){*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[4]=(word)fp;fp+=3;R[11]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{R[10]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[1],6);fp[7]=R[7];fp[6]=R[3];fp[5]=R[5];fp[4]=R[6];fp[3]=R[8];fp[2]=R[9];R[3]=(word)fp;fp+=8;R[4]=G(R[1],7);R[6]=IFALSE;R[5]=R[8];ob=(word *)R[10];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 223:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],7);R[8]=G(R[1],6);R[4]=G(R[1],2);R[5]=G(R[1],5);R[3]=R[8];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],7);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[4];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[10]=G(R[1],2);R[6]=INULL;R[5]=R[3];R[7]=R[4];R[3]=R[9];R[4]=R[10];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 224:if(acc==2){if(R[4]==IFALSE){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],6);R[3]=G(R[1],5);R[5]=G(R[1],4);R[6]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 225:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[8];R[9]=(word)fp;fp+=3;R[4]=R[3];R[5]=R[6];R[3]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 226:if(acc==1){R[4]=G(R[1],2);R[5]=IFALSE;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 227:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[4]=G(R[1],2);R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 228:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[5]=F(63);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 229:if(acc==1){R[4]=G(R[1],2);if(R[4]==R[3]){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[9]=G(R[2],4);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 230:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],3);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 231:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[5];fp[3]=R[4];fp[2]=R[6];R[8]=(word)fp;fp+=6;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 232:if(acc==4){assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);R[12]=G(R[1],5);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[3];fp[8]=R[6];fp[7]=R[12];fp[6]=R[5];fp[5]=R[11];fp[4]=R[4];fp[3]=R[10];fp[2]=R[9];R[3]=(word)fp;fp+=10;R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 233:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],8);R[6]=G(R[1],6);R[7]=G(R[1],4);R[8]=G(R[1],9);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[5]=R[4];R[4]=R[10];ob=(word *)R[5];acc=3;}else{R[4]=G(R[1],2);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],4);R[5]=G(R[1],3);R[9]=R[4];R[6]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 234:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],2);fp[7]=R[10];fp[6]=R[3];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=R[6];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 235:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[11]=G(R[1],2);R[7]=R[4];R[4]=R[11];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 236:if(acc==5){assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[2],2);R[10]=G(R[1],2);R[11]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[7];fp[7]=R[3];fp[6]=R[6];fp[5]=R[11];fp[4]=R[5];fp[3]=R[4];fp[2]=R[10];R[3]=(word)fp;fp+=9;R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 237:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[5]=G(R[1],8);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],6);R[10]=G(R[2],3);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}else{R[4]=G(R[1],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],3);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 238:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 239:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[12]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[12];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 240:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 241:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=F(1);R[10]=R[4];R[11]=R[6];R[6]=R[3];R[4]=R[7];R[5]=R[8];R[7]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 242:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{assert(pairp(R[3]),R[3],1052);R[4]=G(R[3],1);R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 243:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 244:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 245:if(acc==5){if(R[4]==INULL){if(R[5]==INULL){R[8]=G(R[1],2);R[4]=R[6];ob=(word *)R[8];acc=2;}else{R[8]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[8];acc=2;}}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=F(10);if(R[8]==R[10]){*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[5];R[4]=(word)fp;fp+=3;R[12]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],4);fp[5]=R[7];fp[4]=R[3];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[12];acc=2;}else{*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[4]=R[9];ob=(word *)R[7];acc=5;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 246:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=INULL;R[3]=R[7];R[7]=R[6];R[6]=R[5];R[4]=R[8];R[5]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 247:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[3]=G(R[1],3);R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 248:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=INULL;R[7]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 249:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[7];fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[8]=(word)fp;fp+=7;R[9]=G(R[1],2);if(R[9]==INULL){R[10]=G(R[1],3);assert(pairp(R[10]),R[10],1053);R[3]=G(R[10],2);ob=(word *)R[8];acc=1;}else{R[10]=G(R[2],2);R[11]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[4]=R[9];ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 250:if(acc==5){assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);if(immediatep(R[8])){R[9]=IFALSE;}else{word h=V(R[8]);R[9]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[10]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[1],3);fp[7]=R[7];fp[6]=R[5];fp[5]=R[3];fp[4]=R[6];fp[3]=R[9];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[5]=F(2);R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 251:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],7);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=F(1);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],5);R[5]=G(R[1],7);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=G(R[1],6);R[9]=G(R[1],4);R[10]=F(0);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 252:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],2);R[5]=F(0);R[9]=R[4];R[6]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 253:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[12]=F(1);R[8]=R[5];R[5]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 254:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 255:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=F(0);R[13]=F(1);R[9]=R[5];R[5]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 256:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[11];R[13]=(word)fp;fp+=3;R[8]=R[4];R[5]=R[3];R[3]=R[12];R[4]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 257:if(acc==1){R[4]=G(R[1],8);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);if(immediatep(R[5])){R[6]=IFALSE;}else{word h=V(R[5]);R[6]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[7]=G(R[2],2);R[8]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],6);R[13]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[4];fp[8]=R[13];fp[7]=R[12];fp[6]=R[11];fp[5]=R[3];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=10;R[5]=F(1);R[4]=R[8];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 258:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[13]=(word)fp;fp+=10;*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[12];R[14]=(word)fp;fp+=3;R[8]=R[4];R[5]=R[3];R[3]=R[13];R[4]=R[14];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 259:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[1],3);R[5]=F(1);R[6]=G(R[1],2);R[9]=R[4];R[4]=R[12];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 260:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],8);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[7];R[13]=(word)fp;fp+=3;R[8]=R[4];R[5]=R[3];R[3]=R[12];R[4]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 261:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=prim_ref(R[6],R[4]);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 262:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[7]=R[4];R[4]=R[3];R[3]=R[12];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 263:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[3];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[1],2);R[5]=F(10);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 264:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=10;R[14]=F(2);R[8]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 265:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[13]=G(R[1],2);R[7]=R[4];R[4]=R[13];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 266:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],4);fp[9]=R[10];fp[8]=R[9];fp[7]=R[8];fp[6]=R[3];fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=10;R[12]=G(R[1],2);if(R[12]==INULL){R[13]=G(R[1],3);assert(pairp(R[13]),R[13],1053);R[3]=G(R[13],2);ob=(word *)R[11];acc=1;}else{R[13]=G(R[2],2);R[14]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[11];fp[2]=R[14];R[3]=(word)fp;fp+=4;R[4]=R[12];ob=(word *)R[13];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 267:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=10;R[13]=F(0);R[5]=F(1);R[6]=G(R[1],2);R[9]=R[4];R[4]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 268:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=G(R[1],9);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[12];R[13]=(word)fp;fp+=3;R[5]=G(R[1],2);R[9]=R[4];R[6]=R[3];R[3]=R[11];R[4]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 269:if(acc==3){R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 270:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;R[10]=G(R[1],2);if(R[10]==INULL){ob=(word *)R[9];acc=1;}else{R[11]=G(R[2],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=R[10];ob=(word *)R[11];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 271:if(acc==4){R[7]=G(R[1],3);assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[5]=R[7];R[4]=R[8];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 272:if(acc==4){assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[3];fp[6]=R[6];fp[5]=R[5];fp[4]=R[10];fp[3]=R[9];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 273:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=10;R[4]=R[7];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 274:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[13]=(word)fp;fp+=10;R[7]=R[4];R[4]=R[3];R[3]=R[13];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 275:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[12]=(word)fp;fp+=9;R[4]=G(R[1],3);R[14]=G(R[1],2);R[9]=R[5];R[6]=R[3];R[3]=R[12];R[5]=R[14];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 276:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[11]=(word)fp;fp+=8;R[12]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[5];R[4]=R[3];R[3]=R[11];R[5]=R[12];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 277:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[12]=(word)fp;fp+=9;R[13]=F(3);R[8]=R[5];R[4]=R[3];R[3]=R[12];R[5]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 278:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[13]=(word)fp;fp+=10;R[4]=R[3];R[3]=R[13];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 279:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],2);fp[9]=R[10];fp[8]=R[3];fp[7]=R[4];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=10;R[12]=G(R[1],3);if(R[12]==F(0)){assert(pairp(R[6]),R[6],1052);R[3]=G(R[6],1);ob=(word *)R[11];acc=1;}else{R[3]=G(R[1],2);ob=(word *)R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 280:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[5]=R[4];R[4]=R[3];R[3]=R[12];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 281:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[3];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 282:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 283:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[5]=G(R[2],4);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 284:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 285:if(acc==5){assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 286:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[5]=G(R[5],1);R[8]=G(R[2],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[12];fp[6]=R[11];fp[5]=R[10];fp[4]=R[4];fp[3]=R[9];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 287:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[12]=(word)fp;fp+=9;R[4]=R[3];R[3]=R[12];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 288:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[10]=(word)fp;fp+=6;R[6]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 289:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[11]=G(R[1],2);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 290:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[7]=R[5];R[5]=R[4];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 291:if(acc==5){if(R[5]==INULL){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{assert(pairp(R[5]),R[5],1053);R[8]=G(R[5],2);if(R[8]==INULL){R[9]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[9];acc=2;}else{assert(pairp(R[4]),R[4],1053);R[9]=G(R[4],2);assert(pairp(R[8]),R[8],1053);R[5]=G(R[8],2);R[11]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[4]=R[9];ob=(word *)R[7];acc=5;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 292:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[11]=R[4];R[5]=R[3];R[6]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 293:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[10]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[10];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 294:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[3];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 295:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[5]=G(R[2],4);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 296:if(acc==2){R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[8];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[3];R[13]=(word)fp;fp+=3;R[4]=R[6];R[3]=R[11];R[6]=R[13];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 297:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[4]=G(R[1],2);R[5]=F(2);R[6]=F(20);ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 298:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[9]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 299:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 300:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 301:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 302:if(acc==3){R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 303:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[11]=(word)fp;fp+=8;R[4]=R[3];R[3]=R[11];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 304:if(acc==2){R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[3];fp[4]=R[9];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[4];R[14]=(word)fp;fp+=3;R[4]=R[6];R[6]=R[14];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 305:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],2);R[5]=R[4];R[4]=R[8];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 306:if(acc==5){if(R[4]==F(0)){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[5]=F(1);ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 307:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 308:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=F(2);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 309:if(acc==2){if(R[4]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[5];R[4]=R[3];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[5]=G(R[2],3);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=G(R[2],5);R[8]=R[5];R[4]=R[6];R[5]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 310:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 311:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[11]=(word)fp;fp+=8;R[12]=G(R[2],4);R[8]=R[5];R[4]=R[3];R[3]=R[11];R[5]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 312:if(acc==2){R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[3];fp[4]=R[9];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[4];R[14]=(word)fp;fp+=3;R[4]=R[6];R[6]=R[14];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 313:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 314:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[10]=(word)fp;fp+=7;R[11]=F(8);R[8]=R[5];R[4]=R[3];R[3]=R[10];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 315:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[11]=(word)fp;fp+=8;R[4]=R[3];R[3]=R[11];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 316:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[3];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[4]=F(1);R[13]=G(R[1],2);R[8]=R[5];R[5]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 317:if(acc==1){R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[12]=(word)fp;fp+=8;R[13]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[3];R[14]=(word)fp;fp+=3;R[9]=R[6];R[4]=R[5];R[3]=R[12];R[5]=R[13];R[6]=R[14];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 318:if(acc==3){R[6]=G(R[2],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=R[4];R[4]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 319:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[5]=F(0);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 320:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[7]=G(R[2],2);R[4]=G(R[1],2);R[5]=F(1);R[3]=R[6];ob=(word *)R[7];acc=3;}else{R[3]=G(R[2],3);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 321:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(1);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 322:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 323:if(acc==5){assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);if(immediatep(R[8])){R[9]=IFALSE;}else{word h=V(R[8]);R[9]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[10]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 324:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[10]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[10];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 325:if(acc==2){R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[1],2);R[13]=G(R[2],4);R[4]=R[6];R[6]=R[13];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 326:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[6];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[5]=G(R[2],4);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 327:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[4];R[11]=R[6];R[6]=R[3];R[4]=R[7];R[5]=R[8];R[7]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 328:if(acc==5){assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 329:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[6]=F(0);R[12]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 330:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 331:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[4]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 332:if(acc==1){R[4]=G(R[1],3);if(R[4]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=G(R[1],5);R[11]=F(10);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{R[5]=G(R[1],2);if(R[5]==IFALSE){R[6]=G(R[2],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[4]=G(R[1],4);R[5]=G(R[2],6);ob=(word *)R[6];acc=3;}else{R[6]=G(R[2],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],7);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[4]=G(R[1],4);R[5]=G(R[2],6);ob=(word *)R[6];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 333:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=G(R[2],3);R[10]=R[4];R[11]=R[6];R[6]=R[3];R[4]=R[7];R[5]=R[8];R[7]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 334:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=F(2);R[10]=R[4];R[11]=R[6];R[6]=R[3];R[4]=R[7];R[5]=R[8];R[7]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 335:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);R[6]=G(R[1],2);R[10]=G(R[2],3);R[11]=R[5];R[4]=R[3];R[3]=R[7];R[5]=R[8];R[7]=R[10];ob=(word *)R[11];acc=5;}else{R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);R[6]=G(R[1],2);R[10]=F(0);R[11]=R[5];R[4]=R[3];R[3]=R[7];R[5]=R[8];R[7]=R[10];ob=(word *)R[11];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 336:if(acc==5){if(R[5]==INULL){R[8]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[6];ob=(word *)R[8];acc=3;}else{R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],5);fp[6]=R[3];fp[5]=R[5];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 337:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],5);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=G(R[1],3);R[11]=G(R[1],2);R[5]=R[6];R[6]=R[11];ob=(word *)R[7];acc=5;}else{R[5]=G(R[2],3);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[9];fp[6]=R[8];fp[5]=R[4];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[4]=G(R[1],2);R[12]=F(1);R[8]=R[5];R[5]=R[12];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 338:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=R[6];R[6]=R[3];R[7]=R[4];R[3]=R[9];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 339:if(acc==3){if(R[4]==F(0)){R[6]=G(R[2],2);R[7]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[5];R[8]=(word)fp;fp+=4;R[5]=G(R[1],2);R[4]=R[3];R[3]=R[8];ob=(word *)R[6];acc=3;}else{R[6]=G(R[2],4);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[9];fp[5]=R[3];fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=F(1);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 340:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[11]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 341:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[9]=R[5];R[5]=R[6];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 342:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 343:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=G(R[2],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 344:if(acc==3){R[6]=G(R[1],2);assert(pairp(R[6]),R[6],1052);R[7]=G(R[6],1);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[9]=G(R[1],3);ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 345:if(acc==2){R[5]=G(R[1],2);R[6]=F(0);R[7]=R[5];R[5]=R[6];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 346:if(acc==5){if(R[4]==INULL){if(R[6]==F(0)){R[8]=IFALSE;R[4]=INULL;R[7]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{R[4]=INULL;R[7]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 347:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);if(R[4]==F(0)){R[5]=G(R[1],5);R[3]=IFALSE;R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],5);R[3]=G(R[1],3);R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[5]=F(10);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 348:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 349:if(acc==2){R[5]=F(48);R[6]=prim_less(R[4],R[5]);if(R[6]==IFALSE){R[7]=F(57);R[8]=prim_less(R[7],R[4]);if(R[8]==IFALSE){R[9]=G(R[1],2);ob=(word *)R[9];acc=3;}else{R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}}else{R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 350:if(acc==4){if(immediatep(R[4])){R[7]=IFALSE;}else{word h=V(R[4]);R[7]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[7]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{*fp=make_header(5,TCLOS);fp[1]=G(R[1],4);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[8];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[5]=F(1);R[4]=R[7];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 351:if(acc==4){R[7]=G(R[1],2);R[8]=prim_ref(R[7],R[4]);R[9]=G(R[1],3);if(R[4]==R[9]){if(R[4]==F(0)){R[10]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[10]=F(1);{word r=(fixval(R[4])|(1< */ + case 352:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=INULL;R[9]=R[5];R[5]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 353:if(acc==4){R[7]=F(8);if(R[5]==R[7]){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{if(R[4]==INULL){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);if(R[8]==F(0)){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[4],1);R[10]=G(R[1],4);R[11]=R[10]&R[9];if(R[11]==F(0)){R[12]=G(R[4],2);R[13]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[12];R[3]=(word)fp;fp+=5;R[15]=F(1);R[4]=R[5];R[5]=R[15];ob=(word *)R[13];acc=3;}else{R[12]=ITRUE;ob=(word *)R[3];R[3]=R[12];acc=1;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 354:if(acc==2){if(R[4]==IFALSE){R[5]=G(R[1],2);R[4]=G(R[2],2);ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],2);R[4]=F(1);ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 355:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=IFALSE;R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 356:if(acc==2){R[5]=F(1);R[6]=R[3]&R[5];if(R[6]==F(0)){R[7]=G(R[1],2);R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],2);R[8]=G(R[2],2);R[3]=R[4];R[4]=R[8];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 357:if(acc==4){*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 358:if(acc==4){assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[3];fp[7]=R[6];fp[6]=R[5];fp[5]=R[11];fp[4]=R[4];fp[3]=R[10];fp[2]=R[9];R[3]=(word)fp;fp+=9;R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 359:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[6]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 360:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 361:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],8);R[6]=G(R[1],7);R[7]=G(R[1],4);R[8]=G(R[1],9);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],5);R[5]=G(R[1],3);R[6]=R[4];R[4]=R[10];ob=(word *)R[6];acc=4;}else{R[4]=G(R[2],3);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[4];R[4]=R[11];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 362:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],6);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[3];fp[7]=R[11];fp[6]=R[6];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=10;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 363:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(8,TCLOS);fp[1]=G(R[2],2);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[11]=G(R[1],3);R[5]=G(R[1],2);R[6]=R[4];R[4]=R[11];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 364:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[3];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 365:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 366:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=F(1);R[10]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 367:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=G(R[2],2);R[10]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 368:if(acc==2){if(R[4]==INULL){R[5]=IFALSE;ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);if(R[5]==INULL){R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 369:if(acc==5){R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[7];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 370:if(acc==3){R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[5]=G(R[1],2);R[11]=R[4];R[4]=R[3];R[6]=R[8];R[3]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 371:if(acc==3){R[6]=G(R[1],5);if(R[5]==R[6]){R[7]=G(R[1],4);R[8]=G(R[1],3);R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=5;}else{R[7]=G(R[1],3);R[6]=G(R[1],2);ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 372:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(6);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 373:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],2);R[6]=G(R[2],2);R[7]=G(R[2],3);R[8]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[5]=F(1);if(R[4]==R[5]){R[6]=G(R[1],2);R[4]=G(R[2],4);R[5]=G(R[2],5);ob=(word *)R[6];acc=3;}else{R[6]=F(2);if(R[4]==R[6]){R[7]=G(R[1],2);R[4]=G(R[2],6);R[5]=G(R[2],7);ob=(word *)R[7];acc=3;}else{R[7]=F(3);if(R[4]==R[7]){R[8]=G(R[1],2);R[4]=G(R[2],8);R[5]=G(R[2],9);ob=(word *)R[8];acc=3;}else{R[8]=G(R[1],2);R[4]=G(R[2],10);R[5]=G(R[2],11);ob=(word *)R[8];acc=3;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 374:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=6;R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 375:if(acc==2){R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 376:if(acc==4){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=G(R[2],4);R[8]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[7];fp[2]=R[8];fp[3]=R[4];R[9]=(word)fp;fp+=4;R[10]=G(R[2],2);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=5;R[12]=F(1);R[4]=R[5];R[5]=R[12];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 377:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[5];fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 378:if(acc==3){R[6]=prim_less(R[5],R[4]);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 379:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 380:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[4];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=7;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 381:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[9];R[11]=(word)fp;fp+=3;R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 382:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 383:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[4];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[10]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[10];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 384:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[6]=(word)fp;fp+=7;R[3]=G(R[1],2);R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 385:if(acc==4){if(R[4]==F(0)){R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);R[12]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[12];fp[2]=R[5];R[5]=(word)fp;fp+=4;ob=(word *)R[7];acc=3;}else{R[7]=G(R[2],5);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],6);fp[6]=R[9];fp[5]=R[5];fp[4]=R[6];fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[5]=F(1);ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 386:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[10];fp[2]=R[9];R[5]=(word)fp;fp+=4;R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 387:if(acc==3){R[6]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[5],2);R[5]=R[7];R[7]=R[6];R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 388:if(acc==5){if(R[6]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[8]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=IFALSE;ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 389:if(acc==2){R[5]=F(1);R[6]=R[3]&R[5];if(R[6]==F(0)){R[7]=G(R[1],4);R[8]=G(R[1],2);R[3]=R[4];R[4]=R[8];ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],3);assert(pairp(R[7]),R[7],1052);R[8]=G(R[7],1);R[6]=G(R[7],2);R[7]=G(R[1],5);R[3]=G(R[1],4);R[5]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 390:if(acc==2){R[5]=G(R[1],2);R[6]=F(2);R[9]=R[6];R[6]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 391:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=IFALSE;ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 392:if(acc==2){R[5]=F(1);R[6]=R[3]&R[5];R[7]=F(0);R[8]=(R[7]==R[6])?ITRUE:IFALSE;R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[11];fp[4]=R[10];fp[3]=R[4];fp[2]=R[9];R[12]=(word)fp;fp+=6;if(R[8]==IFALSE){R[13]=G(R[2],2);R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){R[3]=IFALSE;ob=(word *)R[12];acc=1;}else{R[3]=R[14];ob=(word *)R[12];acc=1;}}else{R[3]=R[8];ob=(word *)R[12];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 393:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],5);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 394:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=F(2);R[9]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 395:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],5);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 396:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 397:if(acc==2){R[5]=G(R[1],2);if(R[4]==R[5]){R[6]=G(R[2],2);*fp=make_header(4,2);fp[1]=R[6];fp[2]=R[4];fp[3]=R[4];R[7]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[7];acc=1;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 398:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==INULL){R[9]=G(R[2],2);R[4]=R[5];R[3]=R[8];ob=(word *)R[9];acc=2;}else{ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 399:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=6;R[10]=R[5];R[6]=R[4];R[4]=R[3];R[5]=R[7];R[3]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 400:if(acc==2){R[5]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[9];fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 401:if(acc==2){R[5]=G(R[1],3);if(R[4]==R[5]){R[6]=G(R[1],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 402:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 403:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[6]=IFALSE;R[11]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 404:if(acc==1){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];}R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 405:if(acc==2){R[5]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],8);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[5]=G(R[1],2);if(R[5]==F(0)){R[8]=G(R[2],3);R[9]=G(R[1],4);*fp=make_header(4,2);fp[1]=R[8];fp[2]=R[9];fp[3]=R[4];R[10]=(word)fp;fp+=4;R[11]=G(R[2],2);R[12]=G(R[1],3);*fp=make_header(4,2);fp[1]=R[11];fp[2]=R[10];fp[3]=R[12];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=1;}else{R[8]=F(1);if(R[5]==R[8]){R[9]=G(R[2],4);R[10]=G(R[1],4);*fp=make_header(4,2);fp[1]=R[9];fp[2]=R[10];fp[3]=R[4];R[11]=(word)fp;fp+=4;R[12]=G(R[2],2);R[13]=G(R[1],3);*fp=make_header(4,2);fp[1]=R[12];fp[2]=R[11];fp[3]=R[13];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=1;}else{R[9]=F(2);if(R[5]==R[9]){R[10]=G(R[1],3);R[11]=INULL;*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;R[13]=G(R[2],5);R[14]=G(R[1],4);*fp=make_header(5,2);fp[1]=R[13];fp[2]=R[14];fp[3]=R[4];fp[4]=R[12];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=1;}else{R[10]=G(R[2],6);R[4]=G(R[2],7);R[3]=R[6];ob=(word *)R[10];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 406:if(acc==3){R[6]=G(R[1],4);R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 407:if(acc==5){if(R[6]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[5]=F(3);ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 408:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);assert(pairp(R[6]),R[6],1053);R[4]=G(R[6],2);R[8]=G(R[2],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[5];fp[4]=R[9];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=8;ob=(word *)R[8];acc=2;}else{R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],5);R[8]=G(R[1],4);R[5]=G(R[1],3);R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 409:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[4],2);R[9]=G(R[1],7);R[3]=G(R[1],6);R[4]=G(R[1],2);R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 410:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[1],4);assert(pairp(R[10]),R[10],1053);R[6]=G(R[10],2);R[7]=G(R[1],6);R[13]=G(R[1],5);R[4]=R[3];R[3]=R[13];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 411:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=INULL;R[10]=R[5];R[5]=R[7];R[7]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 412:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 413:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[5];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 414:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[9]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 415:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;if(R[3]==IFALSE){assert(pairp(R[4]),R[4],1053);R[4]=G(R[4],2);R[11]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[9];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=2;}else{ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 416:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],6);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 417:if(acc==2){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[5]=ob[1];R[6]=ob[2];}{word *ob=(word *)R[6];word hdr;assert(allocp(R[6]),R[6],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}R[9]=G(R[2],2);R[10]=G(R[1],3);R[11]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[11];fp[3]=R[3];fp[2]=R[10];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[7];R[5]=(word)fp;fp+=4;ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 418:if(acc==2){R[5]=G(R[1],3);if(R[4]==R[5]){R[6]=G(R[1],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);if(R[4]==R[6]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 419:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 420:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 421:if(acc==1){R[4]=G(R[1],2);if(R[4]==R[3]){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[2],2);if(R[6]==R[7]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];R[10]=ob[3];R[11]=ob[4];}R[12]=G(R[2],3);R[13]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[13];fp[3]=R[9];fp[2]=R[10];R[3]=(word)fp;fp+=5;R[15]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],5);fp[2]=R[15];R[4]=(word)fp;fp+=3;R[5]=R[11];ob=(word *)R[12];acc=3;}else{R[8]=G(R[1],3);R[3]=R[4];ob=(word *)R[8];acc=1;}}else{R[5]=G(R[1],3);ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 422:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);*fp=make_header(5,2);fp[1]=R[4];fp[2]=R[5];fp[3]=R[6];fp[4]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 423:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[3]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[5];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 424:if(acc==2){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],3);R[8]=(R[6]==R[7])?ITRUE:IFALSE;if(R[8]==IFALSE){R[9]=G(R[1],2);R[10]=(R[6]==R[9])?ITRUE:IFALSE;if(R[10]==IFALSE){R[11]=IFALSE;ob=(word *)R[3];R[3]=R[11];acc=1;}else{ob=(word *)R[3];R[3]=R[10];acc=1;}}else{ob=(word *)R[3];R[3]=R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 425:if(acc==2){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],2);R[8]=(R[6]==R[7])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 426:if(acc==2){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],4);R[8]=(R[6]==R[7])?ITRUE:IFALSE;if(R[8]==IFALSE){R[9]=G(R[1],3);R[10]=(R[6]==R[9])?ITRUE:IFALSE;if(R[10]==IFALSE){R[11]=G(R[1],2);R[12]=(R[6]==R[11])?ITRUE:IFALSE;if(R[12]==IFALSE){R[13]=IFALSE;ob=(word *)R[3];R[3]=R[13];acc=1;}else{ob=(word *)R[3];R[3]=R[12];acc=1;}}else{ob=(word *)R[3];R[3]=R[10];acc=1;}}else{ob=(word *)R[3];R[3]=R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 427:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 428:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 429:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[3]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 430:if(acc==1){R[4]=G(R[1],2);R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[2],2);if(R[6]==R[7]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];R[10]=ob[3];}R[6]=G(R[1],4);R[12]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[12];fp[2]=R[10];R[13]=(word)fp;fp+=5;R[4]=R[3];R[5]=R[9];R[3]=R[13];ob=(word *)R[6];acc=4;}else{R[8]=G(R[2],4);if(R[6]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];R[12]=ob[4];}R[13]=G(R[2],5);R[14]=G(R[1],3);R[15]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],6);fp[2]=R[15];R[4]=(word)fp;fp+=3;R[5]=R[3];R[6]=R[12];R[3]=R[14];ob=(word *)R[13];acc=4;}else{R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 431:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=INULL;R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[3]=R[5];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=INULL;R[6]=G(R[1],2);R[10]=R[4];R[3]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 432:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[9]=R[6];R[6]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 433:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 434:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],5);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);R[6]=G(R[1],3);R[10]=R[4];R[3]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 435:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],6);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[11]=G(R[2],2);R[12]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[12];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],4);R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[2],7);if(R[6]==R[7]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=G(R[2],8);R[3]=G(R[1],5);R[5]=G(R[1],2);R[4]=R[9];ob=(word *)R[10];acc=3;}else{R[8]=G(R[2],9);if(R[6]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];R[12]=ob[4];}R[13]=G(R[2],10);R[14]=G(R[1],3);R[15]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],11);fp[6]=R[15];fp[5]=R[10];fp[4]=R[11];fp[3]=R[14];fp[2]=R[12];R[3]=(word)fp;fp+=7;R[5]=G(R[1],2);R[4]=R[10];ob=(word *)R[13];acc=3;}else{R[9]=G(R[2],12);if(R[6]==R[9]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];R[12]=ob[3];}R[13]=G(R[2],13);R[3]=G(R[1],5);R[6]=G(R[1],2);R[4]=R[11];R[5]=R[12];ob=(word *)R[13];acc=4;}else{R[10]=G(R[2],14);if(R[6]==R[10]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];R[13]=ob[3];}R[14]=G(R[2],15);R[3]=G(R[1],5);R[6]=G(R[1],2);R[4]=R[12];R[5]=R[13];ob=(word *)R[14];acc=4;}else{R[11]=G(R[2],16);if(R[6]==R[11]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[12]=ob[1];R[13]=ob[2];}R[14]=G(R[2],10);R[3]=G(R[1],5);R[5]=G(R[1],2);R[4]=R[13];ob=(word *)R[14];acc=3;}else{R[12]=G(R[2],17);if(R[6]==R[12]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];R[15]=ob[3];}R[6]=G(R[1],3);R[17]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],18);fp[4]=R[6];fp[3]=R[17];fp[2]=R[14];R[3]=(word)fp;fp+=5;R[5]=G(R[1],2);R[4]=R[15];ob=(word *)R[6];acc=4;}else{R[13]=G(R[2],21);R[14]=INULL;*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[14];R[15]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[15];R[16]=(word)fp;fp+=3;R[17]=G(R[2],20);*fp=PAIRHDR;fp[1]=R[17];fp[2]=R[16];R[5]=(word)fp;fp+=3;R[19]=G(R[2],2);R[20]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],19);fp[2]=R[20];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[19];acc=3;}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 436:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[8];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 437:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(126);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 438:if(acc==3){R[6]=F(62);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[8]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 439:if(acc==1){R[4]=F(47);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(60);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 440:if(acc==4){R[7]=F(62);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=F(47);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=F(32);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[12];ob=(word *)R[13];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 441:if(acc==4){R[7]=F(62);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 442:if(acc==1){R[4]=F(60);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 443:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);{word *ob=(word *)R[7];word hdr;assert(allocp(R[7]),R[7],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[4]=G(R[4],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[3];fp[3]=R[8];fp[2]=R[9];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 444:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],2);if(R[7]==IFALSE){ob=(word *)R[6];acc=1;}else{R[8]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[9]=(word)fp;fp+=3;R[5]=R[3];R[4]=R[7];R[3]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 445:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 446:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 447:if(acc==1){R[4]=F(61);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 448:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 449:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=5;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 450:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 451:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 452:if(acc==3){R[6]=G(R[1],4);R[7]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[6];R[8]=(word)fp;fp+=3;R[6]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 453:if(acc==4){R[7]=F(1);R[8]=prim_ref(R[5],R[7]);R[9]=G(R[1],2);if(R[8]==R[9]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];}ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[10]=G(R[1],3);if(R[8]==R[10]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];R[13]=ob[3];}R[14]=G(R[1],4);R[7]=F(0);R[5]=R[12];R[6]=R[13];ob=(word *)R[14];acc=5;}else{R[11]=G(R[1],5);if(R[8]==R[11]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[12]=ob[1];R[13]=ob[2];}R[14]=G(R[1],4);R[6]=INULL;R[7]=F(2);R[5]=R[13];ob=(word *)R[14];acc=5;}else{R[12]=G(R[1],6);if(R[8]==R[12]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];R[15]=ob[3];}R[16]=G(R[1],4);R[5]=R[14];R[6]=R[15];ob=(word *)R[16];acc=5;}else{R[13]=G(R[1],7);if(R[8]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=5),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];R[16]=ob[3];R[17]=ob[4];}R[18]=G(R[1],8);*fp=make_header(5,TCLOS);fp[1]=G(R[1],9);fp[4]=R[3];fp[3]=R[15];fp[2]=R[16];R[3]=(word)fp;fp+=5;*fp=make_header(3,TPROC);fp[1]=G(R[1],10);fp[2]=R[6];R[20]=(word)fp;fp+=3;R[5]=R[4];R[6]=R[17];R[4]=R[20];ob=(word *)R[18];acc=4;}else{R[14]=G(R[1],11);R[4]=G(R[1],12);R[16]=G(R[1],13);R[6]=R[5];R[5]=R[16];ob=(word *)R[14];acc=4;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 454:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=F(2);R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 455:if(acc==5){R[8]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[6]=R[7];ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 456:if(acc==1){R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[1],4);ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=6;R[9]=IFALSE;R[10]=R[5];R[4]=R[3];R[5]=R[6];R[3]=R[8];R[6]=R[9];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 457:if(acc==1){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];}R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[2],4);R[12]=G(R[1],2);R[9]=R[6];R[6]=R[12];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 458:if(acc==3){assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[5],2);R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 459:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[8]=G(R[1],2);assert(pairp(R[8]),R[8],1053);R[3]=G(R[8],2);ob=(word *)R[7];acc=1;}else{R[8]=G(R[1],2);assert(pairp(R[8]),R[8],1053);R[4]=G(R[8],2);R[10]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[7];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 460:if(acc==2){R[5]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 461:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 462:if(acc==2){if(R[4]==F(0)){R[5]=F(48);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[5]=G(R[1],2);R[6]=INULL;R[9]=R[6];R[6]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 463:if(acc==4){if(R[4]==F(0)){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=F(10);ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 464:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=F(48);R[8]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 465:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[7]=G(R[1],4);R[4]=G(R[1],3);R[3]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 466:if(acc==2){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[5]=G(R[1],2);ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 467:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[6]=IFALSE;ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 468:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[3]=G(R[1],5);R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[7];acc=4;}else{assert(pairp(R[3]),R[3],1052);R[4]=G(R[3],1);R[5]=G(R[1],2);R[6]=prim_less(R[5],R[4]);if(R[6]==IFALSE){R[7]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[7];acc=1;}else{R[7]=G(R[3],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[6]=(word)fp;fp+=3;R[9]=G(R[2],2);R[3]=G(R[1],5);R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[9];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 469:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 470:if(acc==4){if(R[4]==INULL){R[7]=G(R[1],2);R[4]=R[5];ob=(word *)R[7];acc=2;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=F(1);R[9]=prim_ref(R[7],R[8]);R[10]=G(R[1],3);if(R[9]==R[10]){{word *ob=(word *)R[7];word hdr;assert(allocp(R[7]),R[7],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];}R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}else{R[11]=G(R[1],4);if(R[9]==R[11]){{word *ob=(word *)R[7];word hdr;assert(allocp(R[7]),R[7],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[12]=ob[1];R[13]=ob[2];R[14]=ob[3];}R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}else{R[12]=G(R[1],5);if(R[9]==R[12]){{word *ob=(word *)R[7];word hdr;assert(allocp(R[7]),R[7],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];}R[15]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[1],7);fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[5];R[5]=R[14];ob=(word *)R[15];acc=3;}else{R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 471:if(acc==3){if(R[3]==IFALSE){R[6]=G(R[1],4);assert(pairp(R[6]),R[6],1053);R[7]=G(R[6],2);R[8]=G(R[1],3);R[9]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[6]=G(R[1],6);R[3]=G(R[1],5);R[4]=R[7];ob=(word *)R[6];acc=4;}else{{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[6]=ob[1];R[7]=ob[2];R[8]=ob[3];}R[9]=G(R[1],4);assert(pairp(R[9]),R[9],1053);R[10]=G(R[9],2);R[11]=G(R[2],2);*fp=make_header(5,2);fp[1]=R[11];fp[2]=R[7];fp[3]=R[8];fp[4]=R[4];R[12]=(word)fp;fp+=5;*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[6]=G(R[1],6);R[3]=G(R[1],5);R[4]=R[10];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 472:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=INULL;R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 473:if(acc==4){if(R[4]==INULL){R[4]=IFALSE;R[8]=R[3];R[3]=R[4];R[5]=R[4];ob=(word *)R[8];acc=3;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=F(1);R[9]=prim_ref(R[7],R[8]);R[10]=G(R[2],2);if(R[9]==R[10]){R[11]=F(2);R[12]=prim_ref(R[7],R[11]);R[13]=G(R[1],2);if(R[12]==R[13]){R[14]=G(R[4],2);R[8]=R[3];R[4]=R[5];R[3]=R[7];R[5]=R[14];ob=(word *)R[8];acc=3;}else{R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}}else{R[4]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 474:if(acc==2){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=INULL;R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 475:if(acc==3){R[6]=F(1);R[7]=prim_ref(R[4],R[6]);R[8]=G(R[1],2);if(R[7]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];}if(R[5]==INULL){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[11]=G(R[5],1);R[12]=prim_ref(R[11],R[6]);if(R[12]==R[8]){{word *ob=(word *)R[11];word hdr;assert(allocp(R[11]),R[11],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];}R[15]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=R[10];R[5]=R[14];ob=(word *)R[15];acc=3;}else{*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[13]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[13];acc=1;}}}else{*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 476:if(acc==1){R[4]=G(R[2],2);*fp=make_header(3,2);fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],2);assert(pairp(R[6]),R[6],1053);R[7]=G(R[6],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 477:if(acc==4){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 478:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 479:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[4];R[9]=(word)fp;fp+=4;R[4]=R[3];R[5]=R[6];R[6]=R[7];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 480:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],2);R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[2],5);if(R[6]==R[7]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[10];acc=2;}else{R[8]=G(R[2],6);if(R[6]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];}R[12]=G(R[2],7);R[13]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],8);fp[3]=R[13];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=R[10];ob=(word *)R[12];acc=3;}else{R[9]=G(R[2],9);if(R[6]==R[9]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];R[12]=ob[3];}R[13]=G(R[2],7);R[14]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],10);fp[3]=R[14];fp[2]=R[12];R[3]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=R[11];ob=(word *)R[13];acc=3;}else{R[10]=G(R[2],11);if(R[6]==R[10]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];}R[13]=G(R[2],7);R[14]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],12);fp[2]=R[14];R[3]=(word)fp;fp+=3;R[4]=G(R[1],3);R[5]=R[12];ob=(word *)R[13];acc=3;}else{R[11]=G(R[2],2);R[12]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],13);fp[2]=R[12];R[3]=(word)fp;fp+=3;R[14]=G(R[2],14);R[5]=R[4];R[4]=R[14];ob=(word *)R[11];acc=3;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 481:if(acc==2){R[5]=G(R[2],2);*fp=make_header(3,2);fp[1]=R[5];fp[2]=R[4];R[4]=(word)fp;fp+=3;R[7]=G(R[1],2);ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 482:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[4]=G(R[2],4);R[6]=G(R[1],2);R[10]=R[5];R[5]=R[3];R[3]=R[7];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 483:if(acc==3){assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 484:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[6];R[4]=(word)fp;fp+=3;R[8]=G(R[1],3);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 485:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[5];fp[2]=R[6];fp[3]=R[4];R[4]=(word)fp;fp+=4;R[8]=G(R[1],3);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 486:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 487:if(acc==5){if(R[6]==INULL){R[7]=R[3];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{assert(pairp(R[6]),R[6],1052);R[8]=G(R[6],1);*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[3];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 488:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[4];R[9]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=R[3];R[3]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 489:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[4]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 490:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 491:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],4);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 492:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 493:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 494:if(acc==4){if(R[5]==INULL){R[7]=G(R[2],2);R[5]=INULL;R[6]=G(R[1],2);ob=(word *)R[7];acc=4;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[5],1);R[9]=G(R[2],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[3];fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[6]=G(R[2],5);R[5]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 495:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[10]=(word)fp;fp+=5;R[4]=R[3];R[3]=R[10];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 496:if(acc==4){R[7]=G(R[1],2);if(R[4]==R[7]){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{if(R[5]==INULL){R[8]=G(R[1],3);R[5]=INULL;R[6]=IFALSE;ob=(word *)R[8];acc=4;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[1],4);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[6]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 497:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[7]=G(R[1],3);R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 498:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=IFALSE;R[11]=R[5];R[5]=R[4];R[4]=R[6];R[6]=R[7];R[7]=R[8];R[8]=R[9];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 499:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 500:if(acc==3){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[6]=F(1);R[7]=prim_ref(R[5],R[6]);R[8]=G(R[1],2);if(R[7]==R[8]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];}*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[10];R[11]=(word)fp;fp+=3;*fp=make_header(3,2);fp[1]=R[8];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{*fp=make_header(3,2);fp[1]=R[8];fp[2]=R[4];R[9]=(word)fp;fp+=3;R[10]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[10];R[11]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 501:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],4);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 502:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 503:if(acc==5){R[8]=G(R[2],2);*fp=make_header(3,2);fp[1]=R[8];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 504:if(acc==2){R[5]=F(34);if(R[4]==R[5]){R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=F(60);if(R[4]==R[6]){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 505:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(60);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 506:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[2],4);R[5]=G(R[2],5);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 507:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=F(62);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 508:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(3,2);fp[1]=R[8];fp[2]=R[9];R[6]=(word)fp;fp+=3;R[11]=G(R[1],3);ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 509:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 510:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=G(R[2],4);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 511:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[10];fp[3]=R[9];fp[2]=R[6];R[11]=(word)fp;fp+=5;R[6]=R[5];R[5]=R[11];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 512:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=G(R[2],4);R[5]=G(R[2],5);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 513:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(47);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 514:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(62);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 515:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(62);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 516:if(acc==5){R[8]=G(R[1],2);R[6]=G(R[2],2);ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 517:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[6]=G(R[1],3);R[7]=G(R[1],2);R[12]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[12];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 518:if(acc==5){R[8]=G(R[1],3);R[9]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[6];fp[2]=R[8];fp[3]=R[9];R[6]=(word)fp;fp+=4;R[11]=G(R[1],4);ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 519:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[6];R[10]=(word)fp;fp+=4;R[6]=R[5];R[5]=R[10];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 520:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=IFALSE;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 521:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(61);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 522:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[9];R[10]=(word)fp;fp+=3;R[6]=R[5];R[5]=R[10];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 523:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[4];fp[4]=R[5];fp[3]=R[7];fp[2]=R[8];R[10]=(word)fp;fp+=8;if(R[6]==IFALSE){R[3]=R[6];ob=(word *)R[10];acc=1;}else{R[11]=G(R[2],2);R[4]=R[6];R[3]=R[10];ob=(word *)R[11];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 524:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],7);R[7]=G(R[1],6);R[8]=G(R[1],5);R[9]=G(R[1],4);R[10]=G(R[1],3);R[11]=R[6];R[6]=R[5];R[3]=R[7];R[4]=R[8];R[5]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 525:if(acc==5){R[8]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 526:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=R[6];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 527:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[6]=G(R[1],3);R[7]=G(R[1],2);R[11]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 528:if(acc==5){R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[10]=G(R[1],3);ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 529:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[5];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[9];R[4]=(word)fp;fp+=3;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 530:if(acc==2){R[5]=G(R[1],2);R[4]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 531:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[11];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 532:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[5];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=F(92);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 533:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 534:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[9];R[10]=(word)fp;fp+=3;R[6]=R[5];R[5]=R[10];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 535:if(acc==5){R[8]=F(92);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 536:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 537:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[6]=G(R[1],3);R[7]=G(R[1],2);R[11]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 538:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[6];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[9];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 539:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[6]=G(R[1],3);R[7]=G(R[1],2);R[12]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[12];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 540:if(acc==5){R[8]=G(R[1],2);R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=G(R[2],2);R[12]=G(R[1],4);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[12];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[5]=R[10];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 541:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 542:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=F(96);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 543:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=F(64);R[9]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=F(123);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 544:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=F(47);R[9]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=F(91);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 545:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=F(58);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 546:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=INULL;R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 547:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 548:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=3;R[10]=G(R[1],4);ob=(word *)R[10];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 549:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 550:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 551:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[4];R[11]=R[7];R[7]=R[3];R[6]=R[5];R[4]=R[8];R[5]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 552:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=6;R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 553:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[5];R[4]=R[3];R[3]=R[9];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 554:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[10];R[6]=(word)fp;fp+=3;R[10]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 555:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 556:if(acc==3){assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 557:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[2],2);R[8]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[5]=R[4];R[4]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 558:if(acc==6){assert(pairp(R[5]),R[5],1052);R[9]=G(R[5],1);R[10]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[1],3);fp[7]=R[8];fp[6]=R[3];fp[5]=R[6];fp[4]=R[7];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[5]=F(10);R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 559:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],6);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=F(20);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],2);R[8]=R[4];R[5]=R[6];R[4]=R[11];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 560:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[3];fp[5]=R[9];fp[4]=R[8];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=F(1);R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 561:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(9,TPROC);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 562:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=G(R[1],8);R[3]=G(R[1],7);R[4]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[5]=R[8];R[8]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 563:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[11]=F(10);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 564:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 565:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[4];fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[8]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 566:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=F(1);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 567:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[10];fp[2]=R[9];R[6]=(word)fp;fp+=4;R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 568:if(acc==2){R[5]=G(R[2],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[4]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[5];R[3]=R[6];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 569:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 570:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[5]=F(3);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 571:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=F(3);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],5);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 572:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(2);R[11]=R[4];R[6]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 573:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[9]=(word)fp;fp+=6;R[10]=F(10);R[8]=R[5];R[4]=R[3];R[3]=R[9];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 574:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 575:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=F(2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 576:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 577:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 578:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[3];R[5]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 579:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],3);R[10]=G(R[1],2);R[11]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 580:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[5]=F(2);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 581:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],5);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 582:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 583:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 584:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 585:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 586:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=F(10);R[10]=R[5];R[4]=R[3];R[3]=R[8];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 587:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=F(2);R[8]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 588:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[11]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 589:if(acc==2){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[4]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 590:if(acc==5){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 591:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[5]=R[3];R[3]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 592:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[6]=G(R[2],4);R[10]=R[5];R[5]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 593:if(acc==2){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 594:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 595:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[5]=F(0);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 596:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[4]=R[9];ob=(word *)R[10];acc=3;}else{R[4]=G(R[1],5);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 597:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[10]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 598:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 599:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 600:if(acc==3){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 601:if(acc==5){if(R[5]==F(0)){ob=(word *)R[6];acc=2;}else{R[8]=F(1);{word r=(fixval(R[5])|(1< */ + case 602:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 603:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 604:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 605:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[5];fp[4]=R[6];fp[3]=R[7];fp[2]=R[9];R[3]=(word)fp;fp+=7;R[5]=G(R[1],2);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 606:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[11]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 607:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 608:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=G(R[1],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 609:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[5]=(word)fp;fp+=3;R[10]=G(R[2],2);R[11]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[11];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[10];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 610:if(acc==5){R[8]=G(R[1],2);R[9]=F(1);R[12]=R[9];R[13]=R[5];R[5]=R[4];R[9]=R[8];R[8]=R[12];R[4]=R[13];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 611:if(acc==7){R[10]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[1],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[5]=G(R[1],4);ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 612:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],4);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=9;if(R[4]==IFALSE){R[12]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[11];R[3]=(word)fp;fp+=3;R[5]=F(2);R[4]=R[8];ob=(word *)R[12];acc=3;}else{R[3]=R[4];ob=(word *)R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 613:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[4];fp[2]=R[5];fp[3]=R[6];R[7]=(word)fp;fp+=4;R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[2],2);R[3]=G(R[1],7);R[4]=G(R[1],5);ob=(word *)R[10];acc=3;}else{R[4]=G(R[1],3);R[5]=G(R[1],6);R[6]=G(R[1],7);R[7]=G(R[1],8);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],2);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 614:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[4];fp[4]=R[5];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[4]=G(R[1],2);R[5]=F(1);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 615:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[5];R[5]=R[7];R[7]=R[9];R[9]=R[4];R[4]=R[6];R[6]=R[8];R[8]=R[3];R[3]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 616:if(acc==6){R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[5]=G(R[1],4);R[6]=G(R[1],5);R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 617:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=R[4];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[8]=R[10];R[3]=R[12];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 618:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[4];fp[4]=R[6];fp[3]=R[7];fp[2]=R[9];R[3]=(word)fp;fp+=7;R[11]=G(R[2],4);R[4]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 619:if(acc==2){if(R[4]==IFALSE){R[5]=G(R[1],4);R[6]=G(R[1],3);*fp=make_header(4,2);fp[1]=R[3];fp[2]=R[5];fp[3]=R[6];R[7]=(word)fp;fp+=4;R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[2],2);R[3]=G(R[1],6);R[4]=G(R[1],5);ob=(word *)R[10];acc=3;}else{R[5]=G(R[1],2);R[6]=G(R[1],6);R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[4]=R[3];R[3]=R[6];R[6]=R[8];R[8]=R[5];R[5]=R[7];R[7]=R[9];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 620:if(acc==5){R[8]=G(R[1],2);ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 621:if(acc==5){R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[5]=G(R[1],4);R[6]=G(R[1],5);R[4]=R[7];ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 622:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=G(R[2],3);R[11]=R[4];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[8]=R[9];R[3]=R[12];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 623:if(acc==5){*fp=make_header(4,2);fp[1]=R[5];fp[2]=R[6];fp[3]=R[7];R[8]=(word)fp;fp+=4;R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[11]=G(R[1],2);ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 624:if(acc==6){R[9]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[8];fp[5]=R[6];fp[4]=R[7];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=F(24);ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 625:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=G(R[1],2);R[12]=IFALSE;R[8]=R[5];R[5]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 626:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],7);R[6]=G(R[1],4);R[7]=INULL;R[8]=G(R[1],3);R[9]=G(R[1],6);R[10]=G(R[1],5);R[11]=R[5];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}else{R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],4);R[10]=G(R[1],3);R[7]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 627:if(acc==6){R[9]=G(R[2],2);R[10]=G(R[1],2);R[11]=G(R[1],3);R[12]=G(R[1],4);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[8];fp[9]=R[3];fp[8]=R[4];fp[7]=R[5];fp[6]=R[7];fp[5]=R[12];fp[4]=R[11];fp[3]=R[10];fp[2]=R[6];R[3]=(word)fp;fp+=11;R[4]=R[6];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 628:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],7);R[6]=G(R[1],2);R[7]=G(R[1],6);R[8]=G(R[1],10);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],9);R[12]=G(R[1],5);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[14]=G(R[1],8);R[8]=R[4];R[5]=R[7];R[4]=R[14];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],2);R[5]=G(R[1],6);R[6]=G(R[1],7);R[7]=G(R[1],8);R[8]=G(R[1],9);R[9]=G(R[1],10);*fp=make_header(7,TPROC);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 629:if(acc==2){R[5]=F(0);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);*fp=make_header(11,TCLOS);fp[1]=G(R[2],4);fp[10]=R[14];fp[9]=R[13];fp[8]=R[12];fp[7]=R[3];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[15]=(word)fp;fp+=11;if(R[6]==IFALSE){R[16]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[15];R[3]=(word)fp;fp+=3;R[4]=R[8];ob=(word *)R[16];acc=2;}else{R[3]=R[6];ob=(word *)R[15];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 630:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],7);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[9];R[3]=(word)fp;fp+=3;R[11]=G(R[1],9);ob=(word *)R[11];acc=1;}else{R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],8);R[8]=G(R[1],9);R[9]=G(R[1],10);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=4;R[4]=G(R[1],7);R[12]=G(R[1],6);R[5]=R[6];R[6]=R[12];ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 631:if(acc==4){R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[7];R[11]=R[5];R[7]=R[6];R[6]=R[3];R[5]=R[4];R[3]=R[8];R[4]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 632:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[8];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 633:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[6];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[4];R[4]=R[11];R[3]=R[12];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 634:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 635:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=G(R[1],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 636:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],4);R[3]=G(R[2],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 637:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],5);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 638:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[5]=F(10);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 639:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 640:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[7]=G(R[2],2);R[5]=G(R[2],3);R[3]=R[6];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 641:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[2],5);R[9]=G(R[1],2);R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{R[4]=G(R[2],6);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],7);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 642:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],3);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 643:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 644:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(10);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 645:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 646:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[2],4);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 647:if(acc==2){R[5]=G(R[1],2);R[6]=F(10);R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 648:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[9]=G(R[2],4);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 649:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{R[9]=G(R[2],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[11]=G(R[2],4);R[5]=R[4];R[4]=R[11];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 650:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[2],5);R[9]=G(R[1],3);R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{R[4]=G(R[2],6);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],7);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 651:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 652:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[2],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 653:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[7]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[6];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 654:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],5);R[8]=G(R[2],6);R[9]=G(R[1],2);R[10]=G(R[2],7);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 655:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 656:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[4];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[6];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 657:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=G(R[2],4);R[6]=G(R[2],5);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 658:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=G(R[2],4);R[11]=R[4];R[6]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 659:if(acc==3){if(R[4]==INULL){R[6]=IFALSE;R[5]=INULL;R[8]=R[3];R[3]=R[6];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 660:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[5],2);R[5]=G(R[4],2);R[9]=G(R[1],4);R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 661:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 662:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=5;R[7]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[6];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 663:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[5];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[5]=(word)fp;fp+=7;R[4]=F(1);ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 664:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=G(R[1],2);R[5]=R[9];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 665:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],3);R[8]=G(R[1],7);R[9]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[2],4);R[5]=F(2);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],6);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[5]=G(R[2],7);R[6]=G(R[2],8);R[13]=R[4];R[4]=R[10];ob=(word *)R[13];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 666:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[5]=G(R[2],4);R[6]=G(R[1],2);R[12]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 667:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 668:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=F(0);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 669:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[7];acc=1;}else{R[8]=G(R[1],2);R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[14]=(word)fp;fp+=3;R[15]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[15];fp[2]=R[14];R[16]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[16];R[5]=(word)fp;fp+=3;R[18]=G(R[2],2);R[4]=G(R[2],3);R[3]=R[7];ob=(word *)R[18];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 670:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=F(1);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 671:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 672:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=INULL;R[9]=R[5];R[3]=R[6];R[6]=R[4];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 673:if(acc==3){*fp=make_header(4,TCLOS);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[5]==INULL){R[3]=R[5];ob=(word *)R[6];acc=1;}else{R[7]=F(46);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 674:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 675:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[4];R[5]=(word)fp;fp+=3;*fp=make_header(3,TPROC);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 676:if(acc==3){R[6]=G(R[2],2);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=5;*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[4];R[4]=(word)fp;fp+=3;R[5]=INULL;R[10]=G(R[1],2);R[11]=R[6];R[3]=R[7];R[6]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 677:if(acc==3){if(R[5]==INULL){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[6];R[7]=(word)fp;fp+=6;R[8]=F(37);if(R[4]==R[8]){R[9]=G(R[2],2);R[4]=R[5];R[3]=R[7];ob=(word *)R[9];acc=2;}else{R[3]=IFALSE;ob=(word *)R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 678:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],5);ob=(word *)R[7];acc=1;}else{R[4]=G(R[1],4);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=F(110);R[4]=R[5];R[5]=R[11];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 679:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=F(48);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TCLOS);fp[1]=G(R[2],5);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[2],6);R[6]=F(0);R[11]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 680:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 681:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[2],2);R[11]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[11];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[9];ob=(word *)R[10];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 682:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[4];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[10]=(word)fp;fp+=7;R[11]=IFALSE;R[8]=R[5];R[4]=R[3];R[3]=R[10];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 683:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[4];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=8;if(R[8]==IFALSE){R[3]=IFALSE;ob=(word *)R[10];acc=1;}else{R[11]=G(R[2],2);R[5]=F(110);R[4]=R[3];R[3]=R[10];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 684:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],5);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],7);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=5;R[4]=G(R[2],4);R[5]=R[6];ob=(word *)R[7];acc=3;}else{R[4]=G(R[2],6);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],7);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=G(R[2],8);R[6]=F(0);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 685:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=INULL;R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 686:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 687:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[8]=R[4];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 688:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=F(0);R[5]=F(1);R[12]=R[4];R[6]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 689:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 690:if(acc==2){R[5]=F(48);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 691:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=G(R[1],2);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 692:if(acc==1){R[4]=G(R[2],6);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[5]=(word)fp;fp+=3;R[10]=G(R[2],2);R[11]=G(R[1],2);R[12]=G(R[1],3);R[13]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[13];fp[3]=R[12];fp[2]=R[11];R[3]=(word)fp;fp+=5;R[4]=G(R[2],4);ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 693:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 694:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 695:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 696:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],7);fp[6]=R[7];fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=7;if(R[3]==IFALSE){R[9]=G(R[2],6);R[10]=INULL;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[11];R[12]=(word)fp;fp+=3;R[13]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[5]=(word)fp;fp+=3;R[15]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[8];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[15];acc=3;}else{R[3]=IFALSE;ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 697:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=G(R[2],4);R[6]=G(R[2],5);R[13]=R[4];R[4]=R[10];ob=(word *)R[13];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 698:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=G(R[2],4);R[6]=G(R[1],2);R[11]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 699:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 700:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(1);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 701:if(acc==2){R[5]=G(R[1],2);R[6]=F(0);R[9]=R[6];R[6]=R[5];R[5]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 702:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=IFALSE;ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 703:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],3);R[6]=G(R[1],2);R[3]=R[4];R[4]=R[6];ob=(word *)R[5];acc=2;}else{R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[3];fp[2]=R[6];R[9]=(word)fp;fp+=7;R[4]=F(48);R[8]=R[5];R[5]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 704:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[9];acc=1;}else{R[10]=G(R[2],2);R[11]=F(57);R[4]=R[5];R[3]=R[9];R[5]=R[11];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 705:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],5);R[4]=G(R[1],2);ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=F(10);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 706:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=F(48);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 707:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 708:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[5]=G(R[1],4);R[9]=G(R[1],5);R[10]=R[6];R[3]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 709:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],3);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 710:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 711:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[4]=R[3];R[3]=R[8];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 712:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[4]=G(R[4],1);R[10]=G(R[2],2);R[3]=R[8];ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 713:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[5]=IFALSE;R[6]=G(R[1],2);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 714:if(acc==1){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];R[6]=ob[3];}R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TPROC);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[4];fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[9]=(word)fp;fp+=7;R[10]=G(R[1],2);R[11]=G(R[2],2);if(R[10]==R[11]){R[3]=IFALSE;ob=(word *)R[9];acc=1;}else{R[12]=G(R[2],3);R[3]=R[9];R[4]=R[10];ob=(word *)R[12];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 715:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 716:if(acc==6){R[9]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[9];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 717:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[1],2);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 718:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 719:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[2],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{assert(pairp(R[3]),R[3],1053);R[4]=G(R[3],2);if(R[4]==INULL){R[5]=G(R[2],3);R[6]=G(R[1],3);R[4]=R[3];R[3]=R[6];ob=(word *)R[5];acc=2;}else{R[5]=G(R[2],4);R[6]=G(R[1],3);R[4]=R[3];R[3]=R[6];ob=(word *)R[5];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 720:if(acc==5){*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=6;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 721:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=G(R[2],4);R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 722:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[10]=(word)fp;fp+=8;if(R[3]==INULL){R[3]=IFALSE;ob=(word *)R[10];acc=1;}else{R[11]=G(R[2],2);R[4]=R[3];R[3]=R[10];ob=(word *)R[11];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 723:if(acc==1){R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],4);R[3]=G(R[1],7);R[4]=G(R[2],2);ob=(word *)R[5];acc=2;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[5]=ob[1];R[6]=ob[2];}R[7]=G(R[2],3);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],4);fp[9]=R[12];fp[8]=R[6];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[5];fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=10;R[14]=G(R[2],5);R[4]=R[5];R[5]=R[14];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 724:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],6);R[6]=G(R[1],7);R[7]=G(R[1],8);R[8]=G(R[1],9);*fp=make_header(6,TCLOS);fp[1]=G(R[2],6);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[2],7);R[5]=G(R[1],2);R[6]=IFALSE;R[13]=R[4];R[4]=R[10];ob=(word *)R[13];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 725:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 726:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=F(1);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=R[6];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 727:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],5);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 728:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],5);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 729:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[4]=(word)fp;fp+=3;R[9]=G(R[1],4);R[3]=G(R[1],5);ob=(word *)R[9];acc=2;}else{R[4]=G(R[1],2);R[5]=G(R[2],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],5);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 730:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=R[5];R[5]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 731:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 732:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[5]=F(0);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 733:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 734:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 735:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 736:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 737:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 738:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[9]=R[5];R[5]=R[6];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 739:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[5];R[4]=R[3];R[3]=R[8];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 740:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[10]=R[5];R[4]=R[6];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 741:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 742:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 743:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 744:if(acc==1){R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[2],2);R[3]=G(R[1],6);R[4]=G(R[1],4);ob=(word *)R[5];acc=2;}else{if(R[3]==IFALSE){R[5]=G(R[2],2);R[3]=G(R[1],6);R[4]=G(R[1],5);ob=(word *)R[5];acc=2;}else{R[5]=G(R[2],3);R[6]=G(R[1],3);R[4]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[9];fp[4]=R[8];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[5];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 745:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 746:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[4]=R[7];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 747:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 748:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[10]=(word)fp;fp+=7;R[11]=G(R[2],4);R[8]=R[5];R[4]=R[3];R[3]=R[10];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 749:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[3];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 750:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[5]=G(R[1],3);R[6]=G(R[1],2);R[12]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 751:if(acc==1){R[4]=G(R[2],6);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],5);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=INULL;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[11];R[12]=(word)fp;fp+=3;R[13]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[4]=(word)fp;fp+=3;R[15]=G(R[2],2);R[16]=G(R[1],4);R[17]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[17];fp[3]=R[16];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[15];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 752:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[9]=IFALSE;R[4]=R[5];R[5]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 753:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);R[10]=IFALSE;R[11]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 754:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],4);R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],5);ob=(word *)R[8];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],5);R[7]=G(R[1],2);R[8]=G(R[1],4);R[9]=G(R[1],3);R[11]=R[5];R[5]=R[8];R[8]=R[4];R[4]=R[7];R[7]=R[3];R[3]=R[6];R[6]=R[9];ob=(word *)R[11];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 755:if(acc==7){*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[5];R[10]=(word)fp;fp+=6;R[11]=G(R[1],2);*fp=make_header(9,TCLOS);fp[1]=G(R[1],3);fp[8]=R[3];fp[7]=R[5];fp[6]=R[10];fp[5]=R[9];fp[4]=R[7];fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[5]=F(4);ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 756:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 757:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 758:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 759:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 760:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],6);R[3]=G(R[1],8);ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=9;R[4]=G(R[1],2);R[14]=IFALSE;R[8]=R[5];R[5]=R[14];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 761:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],6);R[3]=G(R[1],8);ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=10;R[4]=G(R[1],2);R[14]=F(3);R[8]=R[5];R[5]=R[14];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 762:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],6);R[6]=G(R[1],8);R[7]=G(R[1],9);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[9]=G(R[1],5);R[10]=G(R[1],4);R[7]=G(R[1],3);R[12]=G(R[1],2);R[13]=R[9];R[4]=R[3];R[9]=R[5];R[3]=R[8];R[6]=R[10];R[8]=R[12];R[5]=R[13];ob=(word *)R[9];acc=7;}else{R[5]=G(R[2],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],4);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[4]=G(R[1],2);R[14]=IFALSE;R[8]=R[5];R[5]=R[14];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 763:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],6);R[3]=G(R[1],8);ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],5);R[6]=G(R[1],7);R[7]=G(R[1],8);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[9]=G(R[1],4);R[10]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[3];R[3]=R[8];R[8]=R[4];R[4]=R[9];R[9]=R[5];R[5]=R[10];ob=(word *)R[9];acc=7;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 764:if(acc==6){R[9]=G(R[1],2);ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 765:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 766:if(acc==1){R[4]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 767:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 768:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 769:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[8]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 770:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 771:if(acc==2){R[5]=G(R[2],5);R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=G(R[2],2);R[13]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[13];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[11];ob=(word *)R[12];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 772:if(acc==1){R[4]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],8);fp[2]=R[4];R[5]=(word)fp;fp+=3;if(R[3]==IFALSE){R[6]=G(R[2],5);R[7]=INULL;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=G(R[2],2);R[4]=G(R[2],3);R[3]=R[5];R[5]=R[12];ob=(word *)R[13];acc=3;}else{R[6]=G(R[2],7);R[7]=INULL;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=G(R[2],6);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=G(R[2],2);R[4]=G(R[2],3);R[3]=R[5];R[5]=R[12];ob=(word *)R[13];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 773:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 774:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 775:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 776:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[2],4);R[5]=G(R[2],5);R[6]=G(R[2],6);R[11]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 777:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[5]=F(32);R[9]=G(R[1],4);R[10]=R[6];R[3]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 778:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[6]=INULL;R[10]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 779:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=F(1);R[6]=F(100);R[11]=R[5];R[4]=R[3];R[3]=R[8];R[5]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 780:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 781:if(acc==2){if(R[4]==F(0)){R[5]=G(R[1],2);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],3);ob=(word *)R[8];acc=1;}else{R[5]=G(R[1],2);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[3];R[7]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 782:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 783:if(acc==5){if(R[5]==F(0)){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[1],5);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=IFALSE;ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 784:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[11]=F(1);R[8]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 785:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[2],2);R[6]=R[4]&R[5];R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],6);R[10]=G(R[1],5);R[4]=G(R[1],4);R[5]=R[3];R[6]=R[8];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 786:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=G(R[1],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 787:if(acc==2){R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);if(R[7]==IFALSE){R[8]=G(R[2],2);R[3]=R[6];ob=(word *)R[8];acc=2;}else{R[3]=R[4];ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 788:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 789:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[7]=(word)fp;fp+=5;R[4]=G(R[2],4);R[9]=G(R[2],5);R[6]=G(R[2],6);R[11]=R[5];R[3]=R[7];R[5]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 790:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 791:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[5]=G(R[1],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 792:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[4];R[4]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 793:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 794:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 795:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 796:if(acc==2){R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=IFALSE;R[9]=F(0);R[5]=R[8];R[8]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[7];R[7]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 797:if(acc==6){R[9]=G(R[2],2);R[10]=G(R[1],2);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[3];fp[7]=R[5];fp[6]=R[4];fp[5]=R[7];fp[4]=R[10];fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[5]=R[6];R[4]=R[10];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 798:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[12]=(word)fp;fp+=10;R[7]=R[4];R[4]=R[3];R[3]=R[12];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 799:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],8);R[6]=G(R[1],9);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],5);R[9]=G(R[2],2);if(R[8]==R[9]){R[3]=IFALSE;ob=(word *)R[7];acc=1;}else{R[10]=G(R[2],3);R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=2;}}else{if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[6]=G(R[1],3);if(R[5]==R[6]){R[7]=G(R[2],5);R[8]=G(R[1],7);R[9]=G(R[1],9);R[10]=G(R[1],6);R[11]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],6);fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=6;R[13]=G(R[1],8);R[5]=R[4];R[4]=R[13];ob=(word *)R[7];acc=3;}else{R[7]=G(R[2],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],9);R[11]=G(R[1],4);*fp=make_header(8,TCLOS);fp[1]=G(R[2],7);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[13]=G(R[1],8);R[5]=R[4];R[4]=R[13];ob=(word *)R[7];acc=3;}}}else{R[4]=G(R[1],6);R[5]=G(R[1],7);R[6]=G(R[1],8);R[7]=G(R[1],9);*fp=make_header(6,TCLOS);fp[1]=G(R[2],8);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;R[9]=G(R[1],5);R[10]=G(R[2],2);if(R[9]==R[10]){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{R[11]=G(R[2],3);R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 800:if(acc==1){R[4]=G(R[1],4);if(R[4]==IFALSE){R[5]=G(R[2],2);R[6]=G(R[1],5);R[4]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[5];R[3]=R[6];R[5]=R[8];ob=(word *)R[9];acc=3;}else{if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[6]=G(R[2],3);R[7]=G(R[1],3);R[8]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[8];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 801:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 802:if(acc==1){R[4]=G(R[1],2);if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 803:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[5];R[5]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 804:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 805:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=7;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 806:if(acc==1){R[4]=G(R[1],2);if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[3];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[4]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 807:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=IFALSE;R[8]=G(R[1],2);R[11]=R[6];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[4];R[4]=R[11];R[3]=R[12];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 808:if(acc==1){R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],3);R[3]=INULL;ob=(word *)R[5];acc=1;}else{R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 809:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[8]=F(1);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 810:if(acc==2){if(R[4]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=F(1);R[6]=F(16);R[10]=R[5];R[4]=R[3];R[3]=R[7];R[5]=R[8];ob=(word *)R[10];acc=4;}else{R[5]=G(R[1],2);R[3]=INULL;ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 811:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=F(1);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 812:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 813:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],4);R[9]=R[5];R[6]=R[4];R[4]=R[3];R[3]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 814:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[3]=(word)fp;fp+=3;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 815:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 816:if(acc==3){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[4]=G(R[1],4);R[9]=INULL;R[10]=R[6];R[6]=R[5];R[3]=R[7];R[5]=R[9];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 817:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 818:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 819:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[2],4);R[9]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 820:if(acc==4){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{if(R[6]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 821:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[9]=G(R[1],2);R[10]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 822:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 823:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 824:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],3);R[3]=G(R[1],4);R[4]=G(R[1],3);R[6]=G(R[2],2);R[5]=R[7];R[7]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 825:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[5]=F(0);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 826:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=F(8);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 827:if(acc==2){if(R[4]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],4);R[7]=G(R[1],2);R[8]=R[5];R[4]=R[3];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[5]=G(R[2],3);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[2],5);R[12]=INULL;R[9]=R[5];R[5]=R[12];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 828:if(acc==1){if(R[3]==INULL){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 829:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 830:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[10]=R[5];R[5]=R[7];R[7]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 831:if(acc==3){assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 832:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 833:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 834:if(acc==4){R[7]=G(R[2],2);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);R[6]=IFALSE;ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 835:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 836:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 837:if(acc==2){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[5]=ob[1];R[6]=ob[2];}R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[6];R[9]=(word)fp;fp+=4;R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 838:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[4]=R[3];R[3]=R[7];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 839:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 840:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 841:if(acc==3){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[5],2);R[5]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[6]=INULL;ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 842:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],5);R[4]=G(R[1],4);R[9]=G(R[1],3);R[10]=R[6];R[6]=R[5];R[3]=R[7];R[5]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 843:if(acc==3){if(R[4]==INULL){R[6]=INULL;ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[6]=G(R[4],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 844:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 845:if(acc==5){if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);R[4]=G(R[4],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 846:if(acc==4){R[7]=G(R[1],2);ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 847:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=F(12);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 848:if(acc==2){if(R[4]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=G(R[1],2);R[9]=F(1);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[5]=F(1);if(R[4]==R[5]){R[6]=G(R[2],4);R[7]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],5);fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}else{R[6]=F(2);if(R[4]==R[6]){R[7]=G(R[1],3);R[4]=F(0);ob=(word *)R[7];acc=2;}else{R[7]=F(3);if(R[4]==R[7]){R[8]=G(R[1],3);R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[8]=F(4);if(R[4]==R[8]){R[9]=G(R[2],6);R[10]=G(R[1],3);R[5]=G(R[2],7);R[4]=R[3];R[3]=R[10];ob=(word *)R[9];acc=3;}else{R[9]=F(5);if(R[4]==R[9]){R[10]=G(R[2],6);R[11]=G(R[1],3);R[5]=G(R[2],7);R[4]=R[3];R[3]=R[11];ob=(word *)R[10];acc=3;}else{R[10]=F(6);if(R[4]==R[10]){R[11]=G(R[2],6);R[12]=G(R[1],3);R[5]=G(R[2],7);R[4]=R[3];R[3]=R[12];ob=(word *)R[11];acc=3;}else{R[11]=F(7);if(R[4]==R[11]){R[12]=G(R[2],6);R[13]=G(R[1],2);R[14]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],8);fp[3]=R[14];fp[2]=R[13];R[15]=(word)fp;fp+=4;R[5]=G(R[2],7);R[4]=R[3];R[3]=R[15];ob=(word *)R[12];acc=3;}else{R[12]=F(8);if(R[4]==R[12]){R[13]=G(R[2],6);R[14]=G(R[1],2);R[15]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],9);fp[3]=R[15];fp[2]=R[14];R[16]=(word)fp;fp+=4;R[5]=G(R[2],7);R[4]=R[3];R[3]=R[16];ob=(word *)R[13];acc=3;}else{R[13]=F(9);if(R[4]==R[13]){R[14]=G(R[2],10);R[4]=G(R[1],2);R[16]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],11);fp[4]=R[16];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[5]=R[6];ob=(word *)R[14];acc=3;}else{R[14]=G(R[2],12);R[15]=G(R[1],2);R[16]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],13);fp[3]=R[16];fp[2]=R[15];R[17]=(word)fp;fp+=4;R[6]=G(R[2],14);R[4]=R[3];R[3]=R[17];ob=(word *)R[14];acc=4;}}}}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 849:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[9]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 850:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=F(3);R[10]=R[5];R[4]=R[3];R[3]=R[8];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 851:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=6;if(R[4]==F(0)){R[3]=G(R[2],2);ob=(word *)R[8];acc=1;}else{R[3]=G(R[2],3);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 852:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[4]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[3];R[3]=R[6];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 853:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 854:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 855:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 856:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 857:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 858:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 859:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[8];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=G(R[2],4);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 860:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[2],4);R[8]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 861:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 862:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=G(R[2],4);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 863:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 864:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=G(R[2],4);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 865:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[1],2);R[6]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 866:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 867:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[5];R[5]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 868:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 869:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[8]=R[4];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 870:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[6];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 871:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 872:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[5]=F(2);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 873:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=F(1);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],5);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 874:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=F(10);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 875:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[5]=F(0);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 876:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 877:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[9];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 878:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[5]=(word)fp;fp+=3;R[9]=G(R[2],2);R[10]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[10];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=F(1);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],3);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 879:if(acc==3){assert(pairp(R[4]),R[4],1052);R[6]=G(R[4],1);assert(pairp(R[5]),R[5],1052);R[5]=G(R[5],1);R[8]=G(R[1],2);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 880:if(acc==4){if(R[4]==INULL){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=F(1);R[9]=prim_ref(R[7],R[8]);R[10]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 881:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],3);R[4]=R[5];R[3]=R[7];R[5]=R[8];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=F(2);R[3]=prim_ref(R[5],R[6]);R[8]=G(R[1],5);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 882:if(acc==4){if(R[5]==F(0)){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[4]==INULL){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[7]=G(R[4],2);R[8]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 883:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[6];R[10]=R[5];R[5]=R[3];R[6]=R[4];R[4]=R[9];R[3]=R[10];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 884:if(acc==3){R[6]=G(R[1],2);ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 885:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[8]=IFALSE;R[9]=R[6];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 886:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=F(1);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[2],3);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(1);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 887:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 888:if(acc==5){R[8]=prim_sys(fixval(R[4]), R[5], R[6], R[7]);ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 889:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 890:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 891:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 892:if(acc==3){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 893:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 894:if(acc==3){R[6]=G(R[1],2);R[7]=INULL;R[8]=IFALSE;R[11]=R[7];R[7]=R[8];R[8]=R[6];R[6]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 895:if(acc==6){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];}if(R[10]==INULL){if(R[7]==IFALSE){R[11]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[5]=R[9];ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[5]=R[9];ob=(word *)R[11];acc=3;}}else{R[11]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[1],7);fp[6]=R[8];fp[5]=R[3];fp[4]=R[10];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[5]=IFALSE;ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 896:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=prim_less(R[3],R[7]);R[9]=G(R[1],6);R[3]=G(R[1],5);R[5]=G(R[1],4);R[7]=R[8];R[8]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 897:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[4]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 898:if(acc==3){R[6]=G(R[1],2);if(R[5]==R[6]){R[7]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[4];ob=(word *)R[7];acc=3;}else{R[7]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[1],6);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[9]=F(1);R[4]=R[5];R[5]=R[9];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 899:if(acc==2){R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 900:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[4];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 901:if(acc==2){R[5]=G(R[2],4);if(R[3]==R[5]){R[6]=G(R[1],3);R[7]=F(0);R[3]=R[4];R[4]=R[7];ob=(word *)R[6];acc=2;}else{R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[4];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[4]=G(R[1],2);R[5]=R[3];R[3]=R[8];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 902:if(acc==2){R[5]=G(R[1],3);R[6]=G(R[1],2);R[4]=R[3];R[3]=R[6];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 903:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=F(1);ob=(word *)R[6];acc=3;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(40);if(R[6]==R[7]){R[8]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[10]=G(R[1],6);R[6]=INULL;R[5]=R[4];R[4]=R[10];ob=(word *)R[8];acc=4;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];R[10]=ob[3];}R[11]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[1],8);fp[5]=R[3];fp[4]=R[9];fp[3]=R[8];fp[2]=R[10];R[3]=(word)fp;fp+=6;R[4]=R[9];R[5]=R[10];ob=(word *)R[11];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 904:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==IFALSE){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[4]=G(R[2],4);R[10]=G(R[1],4);R[6]=INULL;R[12]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}else{R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],5);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[4]=G(R[2],4);R[10]=G(R[1],4);R[6]=INULL;R[12]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}}else{R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],7);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);if(R[7]==IFALSE){R[3]=G(R[2],6);ob=(word *)R[6];acc=1;}else{R[3]=G(R[2],4);ob=(word *)R[6];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 905:if(acc==1){R[4]=G(R[1],2);*fp=NUMHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=G(R[2],4);R[10]=INULL;R[11]=R[6];R[6]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 906:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[5]=G(R[2],4);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 907:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[8]=INULL;R[9]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 908:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 909:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],3);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 910:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=R[7];R[5]=R[3];R[7]=R[4];R[3]=R[6];R[6]=R[9];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 911:if(acc==2){R[5]=F(93);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[8]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 912:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],4);R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=F(93);R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[11]=G(R[2],4);R[12]=G(R[1],3);R[13]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[13];fp[5]=R[4];fp[4]=R[12];fp[3]=R[6];fp[2]=R[9];R[3]=(word)fp;fp+=7;R[15]=G(R[2],6);R[6]=R[5];R[4]=R[10];R[5]=R[15];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 913:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],2);R[7]=G(R[1],5);R[8]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],4);R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=F(125);R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[11]=G(R[2],4);R[12]=G(R[1],3);R[13]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[13];fp[5]=R[4];fp[4]=R[12];fp[3]=R[6];fp[2]=R[9];R[3]=(word)fp;fp+=7;R[15]=G(R[2],6);R[6]=R[5];R[4]=R[10];R[5]=R[15];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 914:if(acc==1){R[4]=F(123);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(35);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 915:if(acc==1){R[4]=F(91);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(35);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 916:if(acc==2){if(R[4]==INULL){R[5]=G(R[1],2);ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=INULL;R[8]=F(0);R[9]=ITRUE;R[12]=R[5];R[13]=R[8];R[3]=R[6];R[5]=R[7];R[6]=R[7];R[8]=R[9];R[7]=R[13];R[9]=R[13];ob=(word *)R[12];acc=7;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 917:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(15);if(R[6]==R[7]){R[8]=F(12);{uint64_t r=(uint64_t)fixval(R[5])<<(FBITS-fixval(R[8]));R[9]=F(r>>FBITS);R[10]=F(r&FMAX);}R[11]=F(2);{word res=fixval(R[9])+fixval(R[11]);R[13]=BOOL(res&(1<>TPOS)&63);}R[10]=G(R[1],2);R[4]=G(R[1],4);ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 918:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(32);if(R[7]==R[8]){R[9]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],4);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[11];acc=2;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==R[8]){R[12]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],5);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[12];acc=2;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[10]){R[13]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],6);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[13];acc=2;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==F(0)){R[14]=G(R[1],7);ob=(word *)R[14];acc=3;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[14]=F((ob>>TPOS)&63);}if(R[14]==F(0)){R[15]=G(R[1],7);ob=(word *)R[15];acc=3;}else{if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[15]=G(R[1],8);ob=(word *)R[15];acc=3;}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 919:if(acc==3){R[6]=F(1);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[9]=G(R[1],2);R[6]=F(0);R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 920:if(acc==3){if(R[5]==F(0)){R[6]=G(R[1],2);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=INULL;ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 921:if(acc==3){if(R[4]==INULL){R[6]=F(0);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[6]=ob[1];R[7]=ob[2];}if(R[7]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{if(R[6]==F(0)){R[4]=R[7];ob=(word *)R[5];acc=3;}else{R[8]=G(R[1],2);R[5]=INULL;ob=(word *)R[8];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 922:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(5);R[7]=(R[6]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 923:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],5);R[5]=F(23);if(R[4]==R[5]){R[6]=G(R[1],2);R[7]=G(R[6],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[12]=(word)fp;fp+=6;R[13]=G(R[7],2);if(R[13]==INULL){R[3]=G(R[7],1);ob=(word *)R[12];acc=1;}else{R[3]=R[7];ob=(word *)R[12];acc=1;}}else{R[6]=G(R[1],6);R[7]=F(1);{uint64_t res=(uint64_t)fixval(R[6])<>FBITS);R[9]=F(res&FMAX);}{word res=fixval(R[4])+fixval(R[7]);R[11]=BOOL(res&(1< */ + case 924:if(acc==5){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=F(0);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[4],2);R[10]=G(R[5],2);if(R[9]==INULL){if(R[10]==INULL){R[11]=G(R[5],1);R[12]=G(R[1],2);if(R[11]==R[12]){if(R[6]==F(0)){R[13]=F(0);ob=(word *)R[3];R[3]=R[13];acc=1;}else{R[13]=G(R[4],1);R[14]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;R[5]=F(1);R[4]=R[6];ob=(word *)R[14];acc=3;}}else{R[13]=G(R[4],1);R[14]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[1],6);fp[4]=R[3];fp[3]=R[6];fp[2]=R[13];R[3]=(word)fp;fp+=5;R[5]=F(1);R[4]=R[11];ob=(word *)R[14];acc=3;}}else{R[11]=F(0);ob=(word *)R[3];R[3]=R[11];acc=1;}}else{if(R[10]==INULL){R[11]=G(R[4],2);R[12]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[1],7);fp[5]=R[7];fp[4]=R[3];fp[3]=R[11];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=F(24);R[4]=R[6];ob=(word *)R[12];acc=3;}else{R[4]=G(R[4],2);R[5]=G(R[5],2);ob=(word *)R[7];acc=5;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 925:if(acc==4){if(R[4]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);R[9]=F(24);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}{word ob=R[4];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==F(0)){{uint64_t res=(uint64_t)fixval(R[4])<>FBITS);R[15]=F(res&FMAX);}if(R[14]==F(0)){if(R[11]==F(0)){ob=(word *)R[3];R[3]=R[15];acc=1;}else{R[16]=INULL;*fp=NUMHDR;fp[1]=R[15];fp[2]=R[16];R[4]=(word)fp;fp+=3;R[18]=G(R[1],2);R[5]=R[11];ob=(word *)R[18];acc=3;}}else{if(R[11]==F(0)){R[16]=INULL;*fp=NUMHDR;fp[1]=R[14];fp[2]=R[16];R[17]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[15];fp[2]=R[17];R[18]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[18];acc=1;}else{R[16]=INULL;*fp=NUMHDR;fp[1]=R[14];fp[2]=R[16];R[17]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[15];fp[2]=R[17];R[4]=(word)fp;fp+=3;R[19]=G(R[1],2);R[5]=R[11];ob=(word *)R[19];acc=3;}}}else{R[14]=F(32);if(R[13]==R[14]){{uint64_t res=(uint64_t)fixval(R[4])<>FBITS);R[16]=F(res&FMAX);}if(R[15]==F(0)){if(R[11]==F(0)){R[17]=prim_cast((word *)R[16],fixval(R[14])&63);ob=(word *)R[3];R[3]=R[17];acc=1;}else{R[17]=INULL;*fp=NUMHDR;fp[1]=R[16];fp[2]=R[17];R[4]=(word)fp;fp+=3;R[19]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[11];ob=(word *)R[19];acc=3;}}else{R[17]=INULL;*fp=NUMHDR;fp[1]=R[15];fp[2]=R[17];R[18]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[16];fp[2]=R[18];R[4]=(word)fp;fp+=3;R[20]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[11];ob=(word *)R[20];acc=3;}}else{R[15]=F(40);if(R[13]==R[15]){R[16]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[1],6);fp[3]=R[3];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[6]=R[8];R[5]=R[12];ob=(word *)R[16];acc=4;}else{R[16]=F(41);if(R[13]==R[16]){R[17]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[1],7);fp[3]=R[3];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[6]=R[8];R[5]=R[12];ob=(word *)R[17];acc=4;}else{R[17]=G(R[1],8);R[18]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[18];ob=(word *)R[17];acc=4;}}}}}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(40);if(R[8]==R[9]){*fp=make_header(5,TCLOS);fp[1]=G(R[1],10);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=G(R[1],11);ob=(word *)R[6];acc=4;}else{R[10]=G(R[1],8);R[11]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 926:if(acc==4){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);R[9]=F(24);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}if(R[11]==F(0)){{word ob=R[4];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==F(0)){{uint64_t r=(uint64_t)fixval(R[4])<<(FBITS-fixval(R[12]));R[14]=F(r>>FBITS);R[15]=F(r&FMAX);}ob=(word *)R[3];R[3]=R[14];acc=1;}else{R[14]=F(32);if(R[13]==R[14]){{uint64_t r=(uint64_t)fixval(R[4])<<(FBITS-fixval(R[12]));R[15]=F(r>>FBITS);R[16]=F(r&FMAX);}if(R[15]==F(0)){ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[17]=G(R[1],2);R[4]=R[15];ob=(word *)R[17];acc=2;}}else{R[15]=F(40);if(R[13]==R[15]){R[16]=G(R[1],3);R[5]=R[12];ob=(word *)R[16];acc=3;}else{R[16]=F(41);if(R[13]==R[16]){R[17]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[12];ob=(word *)R[17];acc=3;}else{R[17]=G(R[1],5);R[18]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[18];ob=(word *)R[17];acc=4;}}}}}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==F(0)){ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[14]=F(32);if(R[13]==R[14]){ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[15]=F(40);if(R[13]==R[15]){R[16]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[1],8);fp[3]=R[3];fp[2]=R[12];R[3]=(word)fp;fp+=4;R[5]=R[11];ob=(word *)R[16];acc=3;}else{R[16]=F(41);if(R[13]==R[16]){R[17]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[1],9);fp[3]=R[3];fp[2]=R[12];R[3]=(word)fp;fp+=4;R[5]=R[11];ob=(word *)R[17];acc=3;}else{R[17]=G(R[1],5);R[18]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[18];ob=(word *)R[17];acc=4;}}}}}}else{R[8]=F(40);if(R[7]==R[8]){if(R[4]==F(0)){R[9]=F(0);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[4],2);R[10]=G(R[1],10);*fp=make_header(5,TPROC);fp[1]=G(R[1],11);fp[4]=R[6];fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=5;R[12]=F(24);R[4]=R[5];R[5]=R[12];ob=(word *)R[10];acc=3;}}else{R[9]=G(R[1],5);R[10]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 927:if(acc==3){{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(42);if(R[6]==R[7]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=F(1);if(R[8]==R[10]){R[11]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[9];ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=4;R[5]=R[9];ob=(word *)R[11];acc=3;}}else{R[8]=F(32);if(R[6]==R[8]){R[9]=IFALSE;R[7]=R[3];R[3]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{R[9]=F(41);if(R[6]==R[9]){R[10]=IFALSE;R[7]=R[3];R[3]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{if(R[5]==F(0)){R[10]=IFALSE;R[7]=R[3];R[3]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{R[10]=ITRUE;R[7]=R[3];R[3]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 928:if(acc==3){if(R[5]==F(0)){R[6]=F(0);R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[8]=F(1);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 929:if(acc==3){if(R[5]==F(0)){R[6]=F(0);R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){R[7]=G(R[1],2);ob=(word *)R[7];acc=3;}else{R[7]=F(40);if(R[6]==R[7]){R[8]=G(R[1],3);ob=(word *)R[8];acc=3;}else{R[8]=G(R[1],4);R[4]=G(R[1],5);ob=(word *)R[8];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 930:if(acc==3){if(R[4]==INULL){R[6]=F(0);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[6]=ob[1];R[7]=ob[2];}if(R[6]==F(0)){R[4]=R[7];ob=(word *)R[5];acc=3;}else{if(R[7]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=INULL;*fp=NUMHDR;fp[1]=R[6];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[1],2);R[4]=R[7];ob=(word *)R[10];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 931:if(acc==1){{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}if(R[4]==F(0)){R[5]=G(R[1],2);ob=(word *)R[5];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(32);if(R[5]==R[6]){R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(40);if(R[7]==R[8]){R[9]=G(R[1],2);ob=(word *)R[9];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],2);ob=(word *)R[11];acc=1;}else{R[11]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[11];acc=1;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 932:if(acc==6){if(R[7]==F(0)){R[9]=G(R[1],3);ob=(word *)R[9];acc=4;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[3];fp[5]=R[10];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[7];R[7]=(word)fp;fp+=4;ob=(word *)R[9];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 933:if(acc==6){if(R[7]==F(0)){R[9]=G(R[1],3);ob=(word *)R[9];acc=4;}else{R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[7];R[7]=(word)fp;fp+=4;ob=(word *)R[9];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 934:if(acc==3){{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(19);if(R[8]==R[9]){if(immediatep(R[4])){R[10]=IFALSE;}else{word h=V(R[4]);R[10]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[11]=F(4);R[3]=(R[11]==R[10])?ITRUE:IFALSE;ob=(word *)R[7];acc=1;}else{R[3]=IFALSE;ob=(word *)R[7];acc=1;}}else{R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 935:if(acc==4){if(immediatep(R[4])){R[7]=IFALSE;}else{word h=V(R[4]);R[7]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[7]==F(0)){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[6];fp[4]=R[5];fp[3]=R[7];fp[2]=R[4];R[4]=(word)fp;fp+=6;ob=(word *)R[4];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 936:if(acc==1){R[4]=G(R[1],3);if(R[3]==R[4]){R[5]=G(R[1],6);R[3]=ITRUE;ob=(word *)R[5];acc=1;}else{if(R[3]==F(0)){R[5]=G(R[2],2);R[6]=G(R[1],6);R[7]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[4]=G(R[2],4);R[10]=F(2);R[11]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}else{if(R[3]==IFALSE){R[5]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],5);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(5,TPROC);fp[1]=G(R[2],6);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[4]=G(R[1],2);R[8]=R[5];R[5]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 937:if(acc==6){if(R[6]==F(0)){{word ob=R[4];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=F(14);if(R[9]==R[10]){R[11]=F(1);R[12]=prim_set(R[4],R[11],R[7]);ob=(word *)R[3];R[3]=R[12];acc=1;}else{ob=(word *)R[3];R[3]=R[7];acc=1;}}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];}R[12]=G(R[1],2);*fp=make_header(9,TCLOS);fp[1]=G(R[1],3);fp[8]=R[3];fp[7]=R[4];fp[6]=R[8];fp[5]=R[10];fp[4]=R[7];fp[3]=R[11];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[14]=F(1);R[4]=R[5];R[5]=R[14];ob=(word *)R[12];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 938:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);if(R[5]==IFALSE){R[6]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],3);R[7]=(immediatep(R[6]))?IFALSE:F(hdrsize(V(R[6]))-1);if(R[5]==R[7]){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}{word ob=R[6];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[8]==R[9]){if(immediatep(R[4])){R[10]=IFALSE;}else{word h=V(R[4]);R[10]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[10]==IFALSE){R[11]=G(R[2],2);R[3]=G(R[1],4);R[13]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[13];R[14]=(word)fp;fp+=3;R[7]=R[5];R[5]=R[6];R[6]=R[14];ob=(word *)R[11];acc=5;}else{if(immediatep(R[4])){R[11]=IFALSE;}else{word h=V(R[4]);R[11]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(immediatep(R[6])){R[12]=IFALSE;}else{word h=V(R[6]);R[12]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[11]==R[12]){if(R[11]==F(0)){R[13]=G(R[1],4);R[3]=ITRUE;ob=(word *)R[13];acc=1;}else{R[13]=G(R[2],4);R[14]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[14];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[5]=F(1);R[4]=R[11];ob=(word *)R[13];acc=3;}}else{R[13]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[13];acc=1;}}}else{R[10]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[10];acc=1;}}else{R[8]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[8];acc=1;}}}else{R[4]=G(R[2],6);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],7);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 939:if(acc==5){R[8]=prim_ref(R[4],R[6]);R[9]=prim_ref(R[5],R[6]);if(R[8]==R[9]){if(R[6]==F(0)){R[10]=ITRUE;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[10]=F(1);{word r=(fixval(R[6])|(1< */ + case 940:if(acc==6){if(R[7]==F(0)){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=prim_ref(R[4],R[7]);R[10]=prim_ref(R[5],R[7]);*fp=make_header(8,TPROC);fp[1]=G(R[1],2);fp[7]=R[8];fp[6]=R[3];fp[5]=R[4];fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=R[9];R[5]=R[10];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 941:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],2);if(R[4]==F(0)){R[5]=G(R[1],4);R[3]=INULL;ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[9]=F(1);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=F(1);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 942:if(acc==5){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 943:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(15);if(R[7]==R[8]){R[9]=F(1);R[4]=prim_ref(R[4],R[9]);ob=(word *)R[6];acc=4;}else{R[9]=F(19);if(R[7]==R[9]){if(immediatep(R[4])){R[10]=IFALSE;}else{word h=V(R[4]);R[10]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[10]==F(0)){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[11]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=F(1);R[4]=R[10];ob=(word *)R[11];acc=3;}}else{ob=(word *)R[3];R[3]=R[5];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 944:if(acc==5){if(R[5]==F(0)){R[8]=prim_ref(R[4],R[5]);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[6];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[8]=F(1);{word r=(fixval(R[5])|(1< */ + case 945:if(acc==2){if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[5]==F(0)){R[6]=INULL;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[8]=F(1);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 946:if(acc==5){if(R[5]==F(0)){R[8]=prim_ref(R[4],R[5]);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[6];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[8]=prim_ref(R[4],R[5]);R[9]=F(1);{word r=(fixval(R[5])|(1< */ + case 947:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=R[6];ob=(word *)R[8];acc=2;}else{if(R[5]==F(0)){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{assert(pairp(R[4]),R[4],1053);R[8]=G(R[4],2);R[9]=G(R[1],5);*fp=make_header(7,TPROC);fp[1]=G(R[1],6);fp[6]=R[7];fp[5]=R[3];fp[4]=R[8];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[11]=F(1);R[4]=R[5];R[5]=R[11];ob=(word *)R[9];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 948:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=G(R[1],2);R[7]=R[4]&R[6];R[8]=(R[4]==R[7])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 949:if(acc==3){{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(19);if(R[7]==R[8]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[9]=G(R[1],3);R[10]=prim_less(R[5],R[9]);if(R[10]==IFALSE){R[11]=G(R[1],2);ob=(word *)R[11];acc=3;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}}else{R[7]=F(40);if(R[6]==R[7]){R[8]=G(R[1],4);ob=(word *)R[8];acc=3;}else{R[8]=G(R[1],5);R[4]=G(R[1],6);ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 950:if(acc==3){{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(19);if(R[7]==R[8]){R[9]=prim_ref(R[4],R[5]);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[1],5);R[10]=prim_less(R[5],R[9]);if(R[10]==IFALSE){R[11]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],4);ob=(word *)R[11];acc=3;}}}else{R[7]=F(40);if(R[6]==R[7]){R[8]=G(R[1],6);ob=(word *)R[8];acc=3;}else{R[8]=G(R[1],7);R[4]=G(R[1],8);ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 951:if(acc==5){if(R[6]==F(0)){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[8];acc=2;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[4];R[9]=(word)fp;fp+=3;R[10]=G(R[5],2);R[11]=G(R[1],4);*fp=make_header(6,TPROC);fp[1]=G(R[1],5);fp[5]=R[7];fp[4]=R[3];fp[3]=R[9];fp[2]=R[10];R[3]=(word)fp;fp+=6;R[5]=F(1);R[4]=R[6];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 952:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(1);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 953:if(acc==5){if(R[6]==F(0)){R[8]=prim_ref(R[4],R[6]);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[5];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[8]=prim_ref(R[4],R[6]);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[9]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 954:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=F(0);R[10]=R[4];R[11]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[3]=R[11];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 955:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);R[7]=R[5]&R[6];if(R[7]==F(0)){R[4]=G(R[4],2);R[7]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}else{R[8]=G(R[1],5);R[9]=R[5]&R[8];R[10]=G(R[1],2);if(R[10]==R[9]){R[4]=G(R[4],2);R[12]=F(31);R[13]=R[12]&R[5];R[14]=G(R[1],3);R[5]=F(1);R[7]=R[6];R[6]=R[13];ob=(word *)R[14];acc=5;}else{R[11]=G(R[1],7);R[12]=R[11]&R[5];if(R[8]==R[12]){R[4]=G(R[4],2);R[14]=F(15);R[6]=R[14]&R[5];R[16]=G(R[1],3);R[5]=F(2);R[7]=G(R[1],6);ob=(word *)R[16];acc=5;}else{R[13]=G(R[1],9);R[14]=R[13]&R[5];if(R[11]==R[14]){R[4]=G(R[4],2);R[16]=F(7);R[6]=R[16]&R[5];R[18]=G(R[1],3);R[5]=F(3);R[7]=G(R[1],8);ob=(word *)R[18];acc=5;}else{R[15]=IFALSE;R[7]=R[3];R[3]=R[15];ob=(word *)R[7];acc=2;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 956:if(acc==6){if(R[5]==F(0)){R[9]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[6];R[5]=R[7];ob=(word *)R[9];acc=3;}else{if(R[4]==INULL){R[9]=IFALSE;R[7]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{R[9]=G(R[1],4);*fp=make_header(8,TCLOS);fp[1]=G(R[1],5);fp[7]=R[8];fp[6]=R[3];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=8;ob=(word *)R[9];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 957:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(40);if(R[6]==R[7]){R[8]=G(R[1],2);R[5]=G(R[1],3);ob=(word *)R[8];acc=3;}else{R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 958:if(acc==4){if(R[5]==F(0)){R[7]=F(1);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(1);if(R[5]==R[7]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[8]=F(2);if(R[5]==R[8]){R[9]=G(R[1],2);R[5]=R[4];ob=(word *)R[9];acc=3;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[7];ob=(word *)R[10];acc=3;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}R[11]=F(40);if(R[10]==R[11]){R[12]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[7];ob=(word *)R[12];acc=3;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=F(32);if(R[12]==R[13]){R[14]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[1],7);fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[14];acc=2;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[14]=F((ob>>TPOS)&63);}R[15]=F(41);if(R[14]==R[15]){R[16]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[1],8);fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[16];acc=2;}else{R[16]=G(R[1],9);R[17]=G(R[1],10);R[6]=R[5];R[5]=R[4];R[4]=R[17];ob=(word *)R[16];acc=4;}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 959:if(acc==5){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 960:if(acc==1){if(R[3]==F(0)){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],3);R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[6];R[5]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 961:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[8];acc=2;}else{if(R[6]==F(0)){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[8];acc=2;}else{assert(pairp(R[4]),R[4],1053);R[8]=G(R[4],2);R[9]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[5];R[10]=(word)fp;fp+=3;R[11]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[1],6);fp[5]=R[7];fp[4]=R[3];fp[3]=R[8];fp[2]=R[10];R[3]=(word)fp;fp+=6;R[5]=F(1);R[4]=R[6];ob=(word *)R[11];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 962:if(acc==4){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{if(R[4]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[7]=G(R[4],2);R[8]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 963:if(acc==4){if(R[5]==F(0)){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[4]==INULL){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[4],2);R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[8];R[3]=(word)fp;fp+=6;R[11]=F(1);R[4]=R[5];R[5]=R[11];ob=(word *)R[9];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 964:if(acc==5){if(R[5]==F(0)){*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[4];R[8]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[8];acc=1;}else{if(R[4]==INULL){R[8]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[8];acc=3;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],5);fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[12]=F(1);R[4]=R[5];R[5]=R[12];ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 965:if(acc==5){if(R[5]==F(0)){ob=(word *)R[6];acc=2;}else{if(R[4]==INULL){R[8]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[8];acc=3;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];}R[10]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],5);fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[12]=F(1);R[4]=R[5];R[5]=R[12];ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 966:if(acc==4){if(R[4]==INULL){R[7]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[7];acc=3;}else{if(R[5]==F(0)){assert(pairp(R[4]),R[4],1053);R[7]=G(R[4],2);ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[4],2);R[9]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[1],5);fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[8];R[3]=(word)fp;fp+=6;R[11]=F(1);R[4]=R[5];R[5]=R[11];ob=(word *)R[9];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 967:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);R[4]=G(R[1],3);R[5]=R[6];ob=(word *)R[8];acc=3;}else{if(R[5]==F(0)){assert(pairp(R[4]),R[4],1053);R[8]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[8];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);R[9]=G(R[4],2);R[10]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],5);fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[12]=F(1);R[4]=R[5];R[5]=R[12];ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 968:if(acc==4){if(R[4]==INULL){R[7]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[7];acc=3;}else{if(R[5]==F(0)){assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[7]=G(R[4],2);R[8]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[1],5);fp[4]=R[6];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[10]=F(1);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 969:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[6]=F(32);if(R[5]==R[6]){R[7]=F(0);R[8]=prim_cast((word *)R[4],fixval(R[7])&63);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[7]=F(40);if(R[5]==R[7]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[8]=F(41);if(R[5]==R[8]){R[9]=G(R[4],1);R[10]=G(R[4],2);*fp=NUMHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[9]=F(42);if(R[5]==R[9]){R[10]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[10];acc=2;}else{R[10]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[10];R[11]=(word)fp;fp+=3;R[12]=G(R[1],6);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[5]=(word)fp;fp+=3;R[14]=G(R[1],4);R[4]=G(R[1],5);ob=(word *)R[14];acc=3;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 970:if(acc==4){if(R[5]==F(0)){R[7]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[8]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[12]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[12];acc=3;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(43);if(R[7]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==R[8]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];}{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[12]=ob[1];R[13]=ob[2];}R[14]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[1],6);fp[7]=R[3];fp[6]=R[6];fp[5]=R[10];fp[4]=R[13];fp[3]=R[11];fp[2]=R[12];R[3]=(word)fp;fp+=8;R[4]=R[12];R[5]=R[12];ob=(word *)R[14];acc=3;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];}R[12]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[1],7);fp[6]=R[3];fp[5]=R[6];fp[4]=R[11];fp[3]=R[5];fp[2]=R[10];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[12];acc=3;}}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==R[8]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];}R[12]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[1],8);fp[6]=R[3];fp[5]=R[6];fp[4]=R[4];fp[3]=R[11];fp[2]=R[10];R[3]=(word)fp;fp+=7;R[4]=R[10];R[5]=R[10];ob=(word *)R[12];acc=3;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}R[11]=F(42);if(R[10]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[4],1);R[14]=G(R[5],2);R[15]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[1],9);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[13];R[5]=R[14];ob=(word *)R[15];acc=3;}else{R[13]=G(R[4],1);R[4]=G(R[4],2);R[15]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[1],10);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;ob=(word *)R[15];acc=3;}}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[5],2);R[14]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[1],11);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[13];ob=(word *)R[14];acc=3;}else{R[13]=G(R[1],12);ob=(word *)R[13];acc=3;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 971:if(acc==4){if(R[4]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[9]=F((word)(res&FMAX));R[10]=F((word)(res>>FBITS));}if(R[10]==F(0)){ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[11]=INULL;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[9];fp[2]=R[12];R[13]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[13];acc=1;}}else{R[9]=F(40);if(R[8]==R[9]){R[10]=G(R[1],2);R[6]=F(0);ob=(word *)R[10];acc=4;}else{R[10]=F(32);if(R[8]==R[10]){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[11]=F((word)(res&FMAX));R[12]=F((word)(res>>FBITS));}*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[13]=(word)fp;fp+=3;if(R[12]==F(0)){R[3]=R[11];ob=(word *)R[13];acc=1;}else{R[14]=INULL;*fp=NUMHDR;fp[1]=R[12];fp[2]=R[14];R[15]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[15];R[3]=(word)fp;fp+=3;ob=(word *)R[13];acc=1;}}else{R[11]=F(41);if(R[8]==R[11]){R[12]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);ob=(word *)R[12];acc=4;}else{R[12]=F(42);if(R[8]==R[12]){R[13]=G(R[5],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[13];ob=(word *)R[6];acc=4;}else{R[13]=F(43);if(R[8]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],6);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[15];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],7);R[15]=G(R[1],8);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[8]=F(32);if(R[7]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}*fp=make_header(3,TPROC);fp[1]=G(R[1],9);fp[2]=R[3];R[12]=(word)fp;fp+=3;if(R[11]==F(0)){R[3]=R[10];ob=(word *)R[12];acc=1;}else{R[13]=INULL;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[13];R[14]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[14];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=1;}}else{R[10]=F(40);if(R[9]==R[10]){R[11]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],10);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);ob=(word *)R[11];acc=4;}else{if(R[9]==R[8]){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[11]=F((word)(res&FMAX));R[12]=F((word)(res>>FBITS));}if(R[12]==F(0)){ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[13]=INULL;*fp=NUMHDR;fp[1]=R[12];fp[2]=R[13];R[14]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[14];R[15]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[15];acc=1;}}else{R[11]=F(41);if(R[9]==R[11]){R[12]=G(R[1],2);R[6]=F(0);ob=(word *)R[12];acc=4;}else{R[12]=F(42);if(R[9]==R[12]){R[13]=G(R[5],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],11);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[13];ob=(word *)R[6];acc=4;}else{R[13]=F(43);if(R[9]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],12);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[15];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],7);R[15]=G(R[1],8);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[9]=F(40);if(R[7]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],2);R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{if(R[10]==R[9]){R[11]=G(R[1],13);ob=(word *)R[11];acc=3;}else{if(R[10]==R[8]){R[11]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],14);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{R[11]=F(41);if(R[10]==R[11]){R[12]=G(R[1],13);*fp=make_header(3,TPROC);fp[1]=G(R[1],15);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=3;}else{R[12]=F(42);if(R[10]==R[12]){R[13]=G(R[5],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],16);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[13];ob=(word *)R[6];acc=4;}else{R[13]=F(43);if(R[10]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],17);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[15];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],7);R[15]=G(R[1],8);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[10]=F(41);if(R[7]==R[10]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==F(0)){R[12]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],18);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[9]){R[12]=G(R[1],13);*fp=make_header(3,TPROC);fp[1]=G(R[1],19);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=3;}else{if(R[11]==R[8]){R[12]=G(R[1],2);R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[10]){R[12]=G(R[1],13);ob=(word *)R[12];acc=3;}else{R[12]=F(42);if(R[11]==R[12]){R[13]=G(R[5],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],20);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[13];ob=(word *)R[6];acc=4;}else{R[13]=F(43);if(R[11]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],21);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[15];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],7);R[15]=G(R[1],8);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[11]=F(42);if(R[7]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[4],1);R[14]=G(R[5],1);*fp=make_header(6,TCLOS);fp[1]=G(R[1],22);fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[13];R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[13]=F(43);if(R[12]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],23);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[15];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[4],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],24);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[14];ob=(word *)R[6];acc=4;}}}else{R[12]=F(43);if(R[7]==R[12]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==R[12]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[16]=ob[1];R[17]=ob[2];}*fp=make_header(8,TCLOS);fp[1]=G(R[1],25);fp[7]=R[3];fp[6]=R[6];fp[5]=R[14];fp[4]=R[17];fp[3]=R[15];fp[2]=R[16];R[3]=(word)fp;fp+=8;R[4]=R[14];R[5]=R[16];ob=(word *)R[6];acc=4;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],26);fp[5]=R[3];fp[4]=R[6];fp[3]=R[15];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=R[14];ob=(word *)R[6];acc=4;}}else{R[13]=G(R[1],7);R[14]=G(R[1],27);R[6]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[13];acc=4;}}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 972:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){{word r=(fixval(R[4])|(1<>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],10);ob=(word *)R[10];acc=3;}else{if(R[9]==R[8]){{word r=(fixval(R[5])|(1<>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],12);R[6]=ITRUE;ob=(word *)R[11];acc=4;}else{if(R[10]==R[8]){R[11]=G(R[1],4);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[11];acc=3;}else{if(R[10]==R[9]){R[11]=G(R[1],15);ob=(word *)R[11];acc=3;}else{R[11]=F(41);if(R[10]==R[11]){R[12]=G(R[1],16);R[6]=IFALSE;ob=(word *)R[12];acc=4;}else{R[12]=F(42);if(R[10]==R[12]){R[13]=G(R[5],2);R[14]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[1],17);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[13];R[3]=(word)fp;fp+=6;R[5]=R[13];ob=(word *)R[14];acc=3;}else{R[13]=F(43);if(R[10]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TCLOS);fp[1]=G(R[1],18);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],8);R[15]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[10]=F(41);if(R[7]==R[10]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==F(0)){R[12]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[1],19);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[12];acc=3;}else{if(R[11]==R[8]){R[12]=G(R[1],3);R[6]=ITRUE;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[9]){R[12]=G(R[1],16);*fp=make_header(3,TPROC);fp[1]=G(R[1],20);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=IFALSE;ob=(word *)R[12];acc=4;}else{if(R[11]==R[10]){R[12]=G(R[1],15);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[12];acc=3;}else{R[12]=F(42);if(R[11]==R[12]){R[13]=G(R[5],2);R[14]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[1],21);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[13];R[3]=(word)fp;fp+=6;R[5]=R[13];ob=(word *)R[14];acc=3;}else{R[13]=F(43);if(R[11]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TCLOS);fp[1]=G(R[1],22);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],8);R[15]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[11]=F(42);if(R[7]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[4],2);R[14]=G(R[5],2);if(R[13]==R[14]){R[4]=G(R[4],1);R[5]=G(R[5],1);R[17]=G(R[1],23);*fp=make_header(4,TCLOS);fp[1]=G(R[1],24);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;ob=(word *)R[17];acc=3;}else{R[4]=G(R[4],1);R[16]=G(R[5],1);R[17]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[1],25);fp[5]=R[3];fp[4]=R[13];fp[3]=R[14];fp[2]=R[16];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[17];acc=3;}}else{R[13]=F(43);if(R[12]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TCLOS);fp[1]=G(R[1],26);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[4],1);R[15]=G(R[4],2);R[16]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[1],27);fp[4]=R[3];fp[3]=R[4];fp[2]=R[14];R[3]=(word)fp;fp+=5;R[4]=R[5];R[5]=R[15];ob=(word *)R[16];acc=3;}}}else{R[12]=F(43);if(R[7]==R[12]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==R[12]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[16]=ob[1];R[17]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],28);fp[5]=R[3];fp[4]=R[6];fp[3]=R[15];fp[2]=R[17];R[3]=(word)fp;fp+=6;R[4]=R[14];R[5]=R[16];ob=(word *)R[6];acc=4;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],29);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[4]=R[14];ob=(word *)R[6];acc=4;}}else{R[13]=G(R[1],8);R[14]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[13];acc=4;}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 973:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){{word res=fixval(R[4])+fixval(R[5]);R[10]=BOOL(res&(1<>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],3);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{if(R[9]==R[8]){R[10]=G(R[1],10);R[6]=IFALSE;ob=(word *)R[10];acc=4;}else{R[10]=F(32);if(R[9]==R[10]){R[11]=G(R[1],11);R[6]=ITRUE;ob=(word *)R[11];acc=4;}else{R[11]=F(41);if(R[9]==R[11]){R[12]=G(R[1],12);ob=(word *)R[12];acc=3;}else{R[12]=F(42);if(R[9]==R[12]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];}R[15]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[1],13);fp[5]=R[3];fp[4]=R[14];fp[3]=R[6];fp[2]=R[13];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[15];acc=3;}else{R[13]=F(43);if(R[9]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],14);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],8);R[15]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[9]=F(32);if(R[7]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){{word r=(fixval(R[5])|(1<>TPOS)&63);}if(R[11]==F(0)){R[12]=G(R[1],4);R[6]=ITRUE;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[9]){R[12]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],19);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[12];acc=3;}else{if(R[11]==R[8]){R[12]=G(R[1],12);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[12];acc=3;}else{if(R[11]==R[10]){R[12]=G(R[1],10);*fp=make_header(3,TPROC);fp[1]=G(R[1],20);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=IFALSE;ob=(word *)R[12];acc=4;}else{R[12]=F(42);if(R[11]==R[12]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];}R[15]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[1],21);fp[5]=R[3];fp[4]=R[14];fp[3]=R[6];fp[2]=R[13];R[3]=(word)fp;fp+=6;R[5]=R[14];ob=(word *)R[15];acc=3;}else{R[13]=F(43);if(R[11]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],22);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[1],8);R[15]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[15];ob=(word *)R[14];acc=4;}}}}}}}else{R[11]=F(42);if(R[7]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[4],2);R[14]=G(R[5],2);if(R[13]==R[14]){R[4]=G(R[4],1);R[5]=G(R[5],1);*fp=make_header(4,TCLOS);fp[1]=G(R[1],23);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=4;}else{R[4]=G(R[4],1);R[16]=G(R[5],1);R[17]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[1],24);fp[6]=R[3];fp[5]=R[13];fp[4]=R[14];fp[3]=R[6];fp[2]=R[16];R[3]=(word)fp;fp+=7;R[5]=R[14];ob=(word *)R[17];acc=3;}}else{R[13]=F(43);if(R[12]==R[13]){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],25);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[14]=G(R[4],1);R[15]=G(R[4],2);R[16]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[1],26);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[14];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[15];ob=(word *)R[16];acc=3;}}}else{R[12]=F(43);if(R[7]==R[12]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==R[12]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[16]=ob[1];R[17]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],27);fp[5]=R[3];fp[4]=R[6];fp[3]=R[15];fp[2]=R[17];R[3]=(word)fp;fp+=6;R[4]=R[14];R[5]=R[16];ob=(word *)R[6];acc=4;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[14]=ob[1];R[15]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],28);fp[3]=R[3];fp[2]=R[15];R[3]=(word)fp;fp+=4;R[4]=R[14];ob=(word *)R[6];acc=4;}}else{R[13]=G(R[1],8);R[14]=G(R[1],9);R[6]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[13];acc=4;}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 974:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);*fp=make_header(3,43);fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 975:if(acc==3){{word ob=R[5];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[10]=F(q&FMAX);R[11]=F(a-q*b);}if(R[11]==F(0)){ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[12]=IFALSE;ob=(word *)R[3];R[3]=R[12];acc=1;}}else{R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}}else{R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 976:if(acc==5){assert(pairp(R[4]),R[4],1053);R[8]=G(R[4],2);assert(pairp(R[5]),R[5],1053);R[9]=G(R[5],2);if(R[8]==F(0)){R[10]=G(R[1],2);R[5]=R[6];R[4]=R[9];ob=(word *)R[10];acc=3;}else{if(R[9]==F(0)){R[10]=G(R[1],2);R[5]=R[6];R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[10]=G(R[4],1);R[11]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[1],4);fp[8]=R[7];fp[7]=R[3];fp[6]=R[6];fp[5]=R[9];fp[4]=R[5];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[8];R[5]=R[10];ob=(word *)R[11];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 977:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],4);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[4];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],5);ob=(word *)R[6];acc=3;}else{R[4]=G(R[1],4);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],4);fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[4];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[9];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 978:if(acc==1){if(R[3]==F(0)){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],2);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],4);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],4);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],5);fp[7]=R[12];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=G(R[2],6);R[15]=F(0);R[9]=R[6];R[6]=R[15];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 979:if(acc==1){if(R[3]==F(0)){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 980:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],2);if(R[5]==R[6]){R[7]=G(R[4],2);{word ob=R[7];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=F(1);R[10]=F(0);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[9]=G(R[7],2);R[10]=G(R[9],2);if(R[10]==INULL){R[11]=G(R[9],1);R[12]=F(1);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[13]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[13];acc=1;}else{R[11]=F(1);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[9];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}}}else{R[7]=F(1);{uint64_t res=(uint64_t)fixval(R[5])<>FBITS);R[9]=F(res&FMAX);}R[10]=G(R[4],2);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 981:if(acc==4){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 982:if(acc==3){if(R[5]==F(0)){R[6]=G(R[1],2);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[10]=F(q&FMAX);R[11]=F(a-q*b);}R[7]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[7];acc=2;}else{R[8]=F(40);if(R[7]==R[8]){R[9]=F(0);R[7]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{R[9]=F(32);if(R[7]==R[9]){R[10]=F(0);{uint64_t a=((uint64_t)fixval(R[10]))<>FBITS);R[12]=F(q&FMAX);R[13]=F(a-q*b);}R[14]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;R[4]=R[12];ob=(word *)R[14];acc=2;}else{R[10]=F(41);if(R[7]==R[10]){R[11]=F(0);R[7]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[7]=F(40);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[1],7);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[9];acc=3;}else{if(R[8]==R[7]){R[9]=G(R[1],8);ob=(word *)R[9];acc=3;}else{R[9]=F(32);if(R[8]==R[9]){R[10]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[1],9);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=3;}else{R[10]=F(41);if(R[8]==R[10]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],10);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[8]=F(32);if(R[6]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=F(0);{uint64_t a=((uint64_t)fixval(R[10]))<>FBITS);R[12]=F(q&FMAX);R[13]=F(a-q*b);}R[14]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],11);fp[3]=R[3];fp[2]=R[13];R[3]=(word)fp;fp+=4;R[4]=R[12];ob=(word *)R[14];acc=2;}else{if(R[9]==R[8]){R[10]=F(0);{uint64_t a=((uint64_t)fixval(R[10]))<>FBITS);R[12]=F(q&FMAX);R[13]=F(a-q*b);}R[14]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[1],12);fp[3]=R[3];fp[2]=R[12];R[3]=(word)fp;fp+=4;R[4]=R[13];ob=(word *)R[14];acc=2;}else{if(R[9]==R[7]){R[10]=F(0);R[7]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{R[10]=F(41);if(R[9]==R[10]){R[11]=F(0);R[7]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[1],13);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=3;}else{if(R[10]==R[8]){R[11]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[1],14);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=3;}else{if(R[10]==R[7]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],15);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{if(R[10]==R[9]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],16);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[10]=G(R[1],2);R[11]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 983:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[10]=F(q&FMAX);R[11]=F(a-q*b);}ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[8]=F(32);if(R[7]==R[8]){R[9]=F(0);{uint64_t a=((uint64_t)fixval(R[9]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[9]=F(40);if(R[7]==R[9]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[10]=F(41);if(R[7]==R[10]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[7]=F(32);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=F(0);{uint64_t a=((uint64_t)fixval(R[9]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}R[13]=G(R[1],4);R[4]=R[12];ob=(word *)R[13];acc=2;}else{if(R[8]==R[7]){R[9]=F(0);{uint64_t a=((uint64_t)fixval(R[9]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}R[13]=G(R[1],4);R[4]=R[12];ob=(word *)R[13];acc=2;}else{R[9]=F(40);if(R[8]==R[9]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[10]=F(41);if(R[8]==R[10]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[8]=F(40);if(R[6]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[1],6);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=3;}else{if(R[9]==R[7]){R[10]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[1],7);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=3;}else{if(R[9]==R[8]){R[10]=G(R[1],8);ob=(word *)R[10];acc=3;}else{R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],9);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[1],10);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=3;}else{if(R[10]==R[7]){R[11]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[1],11);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=3;}else{if(R[10]==R[8]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],12);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{if(R[10]==R[9]){R[11]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[1],13);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],14);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[10]=G(R[1],2);R[11]=G(R[1],14);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 984:if(acc==3){if(R[5]==F(0)){R[6]=G(R[1],2);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=F(0);{uint64_t a=((uint64_t)fixval(R[8]))<>FBITS);R[10]=F(q&FMAX);R[11]=F(a-q*b);}ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[8]=F(32);if(R[7]==R[8]){R[9]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[9]=F(40);if(R[7]==R[9]){R[10]=F(0);ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[10]=F(41);if(R[7]==R[10]){R[11]=F(0);ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[7]=F(32);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[1],4);ob=(word *)R[9];acc=3;}else{if(R[8]==R[7]){R[9]=F(0);{uint64_t a=((uint64_t)fixval(R[9]))<>FBITS);R[11]=F(q&FMAX);R[12]=F(a-q*b);}ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[9]=F(40);if(R[8]==R[9]){R[10]=F(0);ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[10]=F(41);if(R[8]==R[10]){R[11]=F(0);ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[8]=F(40);if(R[6]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[1],6);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[10];acc=3;}else{if(R[9]==R[7]){R[10]=G(R[1],7);ob=(word *)R[10];acc=3;}else{if(R[9]==R[8]){R[10]=G(R[1],8);ob=(word *)R[10];acc=3;}else{R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],9);*fp=make_header(4,TCLOS);fp[1]=G(R[1],10);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],7);ob=(word *)R[11];acc=3;}else{if(R[10]==R[7]){R[11]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[1],11);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[11];acc=3;}else{if(R[10]==R[8]){R[11]=G(R[1],9);*fp=make_header(4,TCLOS);fp[1]=G(R[1],12);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{if(R[10]==R[9]){R[11]=G(R[1],9);*fp=make_header(4,TCLOS);fp[1]=G(R[1],13);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],2);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[10]=G(R[1],2);R[11]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 985:if(acc==2){{word ob=R[3];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=F(32);R[3]=prim_cast((word *)R[3],fixval(R[6])&63);R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{R[6]=F(41);R[3]=prim_cast((word *)R[3],fixval(R[6])&63);R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 986:if(acc==3){R[6]=F(0);{uint64_t a=((uint64_t)fixval(R[6]))<>FBITS);R[8]=F(q&FMAX);R[9]=F(a-q*b);}if(R[8]==F(0)){ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[10]=F(32);R[11]=prim_cast((word *)R[8],fixval(R[10])&63);ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 987:if(acc==1){if(R[3]==F(0)){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=F(1);R[8]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=F(1);R[7]=F(0);R[8]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[2],5);R[11]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];R[8]=R[10];ob=(word *)R[11];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 988:if(acc==1){if(R[3]==F(0)){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 989:if(acc==7){{word ob=R[6];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}R[11]=F(32);if(R[10]==R[11]){R[12]=IFALSE;ob=(word *)R[3];R[3]=R[12];acc=1;}else{{word ob=R[6];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=F(41);if(R[12]==R[13]){R[14]=IFALSE;ob=(word *)R[3];R[3]=R[14];acc=1;}else{if(R[6]==F(0)){R[14]=G(R[1],2);R[4]=R[8];ob=(word *)R[14];acc=2;}else{R[14]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[1],4);fp[8]=R[9];fp[7]=R[3];fp[6]=R[4];fp[5]=R[5];fp[4]=R[7];fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[5]=R[4];R[4]=R[6];ob=(word *)R[14];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 990:if(acc==3){R[6]=G(R[4],2);if(R[6]==INULL){R[7]=G(R[4],1);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);if(R[7]==F(0)){R[4]=G(R[4],2);ob=(word *)R[5];acc=3;}else{R[8]=G(R[1],2);R[5]=INULL;ob=(word *)R[8];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 991:if(acc==5){if(R[4]==R[5]){R[8]=G(R[1],2);R[5]=F(1);R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[8]=prim_less(R[4],R[5]);if(R[8]==IFALSE){R[9]=F(1);{uint64_t res=(uint64_t)fixval(R[5])<>FBITS);R[11]=F(res&FMAX);}if(R[10]==F(0)){R[12]=G(R[1],3);*fp=make_header(6,TPROC);fp[1]=G(R[1],4);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[11];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[12];acc=2;}else{R[12]=G(R[1],2);R[4]=R[6];R[5]=R[9];ob=(word *)R[12];acc=3;}}else{R[9]=G(R[1],2);R[5]=F(1);R[4]=R[6];ob=(word *)R[9];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 992:if(acc==5){if(R[6]==F(0)){R[8]=F(0);ob=(word *)R[3];R[3]=R[8];acc=1;}else{if(R[4]==R[5]){R[8]=G(R[1],2);R[5]=F(1);R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[8]=prim_less(R[5],R[4]);if(R[8]==IFALSE){R[9]=F(1);{uint64_t r=(uint64_t)fixval(R[5])<<(FBITS-fixval(R[9]));R[10]=F(r>>FBITS);R[11]=F(r&FMAX);}R[12]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[10];R[3]=(word)fp;fp+=6;R[4]=R[6];R[5]=R[9];ob=(word *)R[12];acc=3;}else{ob=(word *)R[3];R[3]=R[6];acc=1;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 993:if(acc==6){if(R[5]==INULL){R[9]=G(R[7],2);if(R[9]==INULL){R[10]=G(R[7],1);R[7]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{R[8]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}}else{{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];}{uint64_t a=((uint64_t)fixval(R[4]))<>FBITS);R[12]=F(q&FMAX);R[13]=F(a-q*b);}if(R[11]==F(0)){*fp=NUMHDR;fp[1]=R[12];fp[2]=R[7];R[7]=(word)fp;fp+=3;R[5]=R[10];R[4]=R[13];ob=(word *)R[8];acc=6;}else{*fp=NUMHDR;fp[1]=R[11];fp[2]=R[7];R[14]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[12];fp[2]=R[14];R[7]=(word)fp;fp+=3;R[5]=R[10];R[4]=R[13];ob=(word *)R[8];acc=6;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 994:if(acc==4){if(R[4]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[9]=F((word)(res&FMAX));R[10]=F((word)(res>>FBITS));}if(R[10]==F(0)){ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[11]=INULL;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[9];fp[2]=R[12];R[13]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[13];acc=1;}}else{R[9]=F(32);if(R[8]==R[9]){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}*fp=make_header(3,TPROC);fp[1]=G(R[1],2);fp[2]=R[3];R[12]=(word)fp;fp+=3;if(R[11]==F(0)){R[3]=R[10];ob=(word *)R[12];acc=1;}else{R[13]=INULL;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[13];R[14]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[14];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=1;}}else{R[10]=F(40);if(R[8]==R[10]){R[11]=G(R[1],3);R[6]=F(0);ob=(word *)R[11];acc=4;}else{R[11]=F(41);if(R[8]==R[11]){R[12]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);ob=(word *)R[12];acc=4;}else{R[12]=G(R[1],5);R[13]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=4;}}}}}else{R[8]=F(32);if(R[7]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}*fp=make_header(3,TPROC);fp[1]=G(R[1],7);fp[2]=R[3];R[12]=(word)fp;fp+=3;if(R[11]==F(0)){R[3]=R[10];ob=(word *)R[12];acc=1;}else{R[13]=INULL;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[13];R[14]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[14];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=1;}}else{if(R[9]==R[8]){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}if(R[11]==F(0)){ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[12]=INULL;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[12];R[13]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[13];R[14]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[14];acc=1;}}else{R[10]=F(40);if(R[9]==R[10]){R[11]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],8);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);ob=(word *)R[11];acc=4;}else{R[11]=F(41);if(R[9]==R[11]){R[12]=G(R[1],3);R[6]=F(0);ob=(word *)R[12];acc=4;}else{R[12]=G(R[1],5);R[13]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=4;}}}}}else{R[9]=F(40);if(R[7]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],3);R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{if(R[10]==R[8]){R[11]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],9);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{if(R[10]==R[9]){R[11]=G(R[1],10);ob=(word *)R[11];acc=3;}else{R[11]=F(41);if(R[10]==R[11]){R[12]=G(R[1],10);*fp=make_header(3,TPROC);fp[1]=G(R[1],11);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=3;}else{R[12]=G(R[1],5);R[13]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=4;}}}}}else{R[10]=F(41);if(R[7]==R[10]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==F(0)){R[12]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],12);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[8]){R[12]=G(R[1],3);R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{if(R[11]==R[9]){R[12]=G(R[1],10);*fp=make_header(3,TPROC);fp[1]=G(R[1],13);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[12];acc=3;}else{if(R[11]==R[10]){R[12]=G(R[1],10);ob=(word *)R[12];acc=3;}else{R[12]=G(R[1],5);R[13]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=4;}}}}}else{R[11]=F(42);if(R[7]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[1],5);R[14]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[13];acc=4;}else{R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[6];acc=4;}}else{R[12]=G(R[1],5);R[13]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=4;}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 995:if(acc==4){if(R[4]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(1);if(R[4]==R[7]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[5]==R[7]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[5])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}if(R[11]==F(0)){ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[12]=INULL;*fp=NUMHDR;fp[1]=R[11];fp[2]=R[12];R[13]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[10];fp[2]=R[13];R[14]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[14];acc=1;}}else{R[10]=G(R[1],2);R[6]=F(0);ob=(word *)R[10];acc=4;}}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],2);R[6]=F(0);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[10];acc=4;}else{R[10]=G(R[4],2);if(R[10]==INULL){R[11]=G(R[5],2);if(R[11]==INULL){R[12]=G(R[4],1);R[13]=G(R[5],1);{uint64_t res=(uint64_t) (((uint64_t) fixval(R[12]))*((uint64_t)fixval(R[13])));R[14]=F((word)(res&FMAX));R[15]=F((word)(res>>FBITS));}if(R[15]==F(0)){ob=(word *)R[3];R[3]=R[14];acc=1;}else{R[16]=INULL;*fp=NUMHDR;fp[1]=R[15];fp[2]=R[16];R[17]=(word)fp;fp+=3;*fp=NUMHDR;fp[1]=R[14];fp[2]=R[17];R[18]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[18];acc=1;}}else{R[4]=G(R[4],1);R[13]=G(R[1],2);R[6]=F(0);ob=(word *)R[13];acc=4;}}else{R[11]=G(R[5],2);if(R[11]==INULL){R[12]=G(R[5],1);R[13]=G(R[1],2);R[6]=F(0);R[5]=R[4];R[4]=R[12];ob=(word *)R[13];acc=4;}else{R[12]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=INULL;R[10]=ITRUE;R[11]=F(0);R[6]=R[4];R[7]=R[5];R[9]=R[8];ob=(word *)R[12];acc=9;}}}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 996:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==F(0)){R[3]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[8]=G(R[2],2);R[9]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[7];R[4]=R[9];ob=(word *)R[8];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 997:if(acc==1){R[4]=G(R[1],3);if(R[4]==F(0)){R[5]=G(R[1],4);ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=G(R[1],2);R[9]=F(1);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 998:if(acc==5){if(R[6]==F(0)){if(R[4]==INULL){R[8]=G(R[1],2);R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[8]=G(R[1],3);ob=(word *)R[8];acc=3;}}else{if(R[4]==INULL){R[8]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[1],5);fp[4]=R[3];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=F(1);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=INULL;*fp=NUMHDR;fp[1]=R[4];fp[2]=R[9];R[4]=(word)fp;fp+=3;ob=(word *)R[7];acc=5;}else{{word ob=R[6];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==F(0)){R[10]=F(1);{word r=(fixval(R[6])|(1< */ + case 999:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=INULL;*fp=NUMHDR;fp[1]=R[4];fp[2]=R[6];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1000:if(acc==5){if(R[5]==INULL){if(R[6]==F(0)){R[8]=INULL;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=INULL;*fp=NUMHDR;fp[1]=R[6];fp[2]=R[8];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}}else{if(R[6]==F(0)){R[8]=G(R[5],1);{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[8])));R[9]=F((word)(res&FMAX));R[10]=F((word)(res>>FBITS));}R[5]=G(R[5],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;R[6]=R[10];ob=(word *)R[7];acc=5;}else{R[8]=G(R[5],1);{uint64_t res=(uint64_t) (((uint64_t) fixval(R[4]))*((uint64_t)fixval(R[8])));R[9]=F((word)(res&FMAX));R[10]=F((word)(res>>FBITS));}{word res=fixval(R[9])+fixval(R[6]);R[12]=BOOL(res&(1< */ + case 1001:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=R[4]^(R[5]^2);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(40);if(R[7]==R[8]){R[9]=G(R[5],1);R[10]=R[4]^(R[9]^2);R[11]=G(R[5],2);*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[7]=F(40);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[4],1);R[10]=R[5]^(R[9]^2);R[11]=G(R[4],2);*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{if(R[8]==R[7]){R[9]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[8]=G(R[1],2);R[9]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[8];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1002:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=R[4]|R[5];ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(40);if(R[7]==R[8]){R[9]=G(R[5],1);R[10]=R[4]|R[9];R[11]=G(R[5],2);*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[7]=F(40);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[4],1);R[10]=R[5]|R[9];R[11]=G(R[4],2);*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{if(R[8]==R[7]){R[9]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[8]=G(R[1],2);R[9]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[8];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1003:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=R[4]&R[5];ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(40);if(R[7]==R[8]){R[9]=G(R[5],1);R[10]=R[4]&R[9];ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[7]=F(40);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[4],1);R[10]=R[9]&R[5];ob=(word *)R[3];R[3]=R[10];acc=1;}else{if(R[8]==R[7]){R[9]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}}}else{R[8]=G(R[1],2);R[9]=G(R[1],3);R[6]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[8];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1004:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],2);if(R[4]==F(0)){R[5]=G(R[1],3);R[3]=INULL;ob=(word *)R[5];acc=1;}else{*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}}else{R[4]=G(R[1],2);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1005:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}if(R[4]==F(0)){R[5]=INULL;*fp=NUMHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=NUMHDR;fp[1]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[9]=G(R[1],3);ob=(word *)R[9];acc=1;}else{R[5]=G(R[1],2);*fp=NUMHDR;fp[1]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1006:if(acc==4){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=F(1);{word r=(fixval(R[5])|(1< */ + case 1007:if(acc==5){if(R[4]==INULL){if(R[6]==F(0)){R[8]=INULL;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=INULL;*fp=NUMHDR;fp[1]=R[6];fp[2]=R[8];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}}else{R[8]=G(R[4],1);{uint64_t res=(uint64_t)fixval(R[8])<>FBITS);R[10]=F(res&FMAX);}R[11]=R[6]|R[10];R[4]=G(R[4],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[11];R[3]=(word)fp;fp+=4;R[6]=R[9];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1008:if(acc==4){if(R[5]==F(0)){ob=(word *)R[3];R[3]=R[4];acc=1;}else{if(R[4]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=F(1);{word r=(fixval(R[5])|(1< */ + case 1009:if(acc==6){if(R[5]==INULL){if(R[7]==IFALSE){if(R[4]==F(0)){R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=INULL;*fp=NUMHDR;fp[1]=R[4];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}else{R[9]=G(R[5],1);{uint64_t r=(uint64_t)fixval(R[9])<<(FBITS-fixval(R[6]));R[10]=F(r>>FBITS);R[11]=F(r&FMAX);}R[12]=R[4]|R[11];R[5]=G(R[5],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],2);fp[4]=R[3];fp[3]=R[12];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[7]=IFALSE;R[4]=R[10];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1010:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==F(0)){R[5]=G(R[1],2);if(R[5]==IFALSE){R[6]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],4);R[3]=F(0);ob=(word *)R[6];acc=1;}}else{R[5]=G(R[1],2);if(R[5]==IFALSE){R[6]=INULL;*fp=NUMHDR;fp[1]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{R[6]=G(R[1],4);R[3]=R[4];ob=(word *)R[6];acc=1;}}}else{R[4]=G(R[1],3);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],4);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1011:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word r=(fixval(R[4])|(1<>TPOS)&63);}if(R[8]==F(0)){R[9]=G(R[1],7);ob=(word *)R[9];acc=3;}else{if(R[8]==R[7]){{word r=(fixval(R[5])|(1<>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],9);R[6]=ITRUE;ob=(word *)R[10];acc=4;}else{if(R[9]==R[7]){R[10]=G(R[1],4);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{if(R[9]==R[8]){R[10]=G(R[1],10);ob=(word *)R[10];acc=3;}else{R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],11);R[6]=IFALSE;ob=(word *)R[11];acc=4;}else{R[11]=G(R[1],5);R[12]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[1],12);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[11];acc=3;}else{if(R[10]==R[7]){R[11]=G(R[1],3);R[6]=ITRUE;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{if(R[10]==R[8]){R[11]=G(R[1],11);*fp=make_header(3,TPROC);fp[1]=G(R[1],13);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=IFALSE;ob=(word *)R[11];acc=4;}else{if(R[10]==R[9]){R[11]=G(R[1],10);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],5);R[12]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[10]=G(R[1],5);R[11]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1012:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){{word res=fixval(R[4])+fixval(R[5]);R[9]=BOOL(res&(1<>TPOS)&63);}if(R[8]==F(0)){{word r=(fixval(R[5])|(1<>TPOS)&63);}if(R[9]==F(0)){R[10]=G(R[1],3);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{if(R[9]==R[7]){R[10]=G(R[1],8);R[6]=ITRUE;ob=(word *)R[10];acc=4;}else{if(R[9]==R[8]){R[10]=G(R[1],10);R[6]=IFALSE;ob=(word *)R[10];acc=4;}else{R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],11);ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],5);R[12]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==F(0)){R[11]=G(R[1],4);R[6]=ITRUE;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{if(R[10]==R[7]){R[11]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[1],12);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[11];acc=3;}else{if(R[10]==R[8]){R[11]=G(R[1],11);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[11];acc=3;}else{if(R[10]==R[9]){R[11]=G(R[1],10);*fp=make_header(3,TPROC);fp[1]=G(R[1],13);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=IFALSE;ob=(word *)R[11];acc=4;}else{R[11]=G(R[1],5);R[12]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}else{R[10]=G(R[1],5);R[11]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1013:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){if(R[4]==F(0)){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(32);R[8]=prim_cast((word *)R[4],fixval(R[7])&63);ob=(word *)R[3];R[3]=R[8];acc=1;}}else{R[7]=F(32);if(R[6]==R[7]){R[8]=F(0);R[9]=prim_cast((word *)R[4],fixval(R[8])&63);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[8]=F(40);if(R[6]==R[8]){R[9]=G(R[4],1);R[10]=G(R[4],2);*fp=make_header(3,41);fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[9]=F(41);if(R[6]==R[9]){R[10]=G(R[4],1);R[11]=G(R[4],2);*fp=NUMHDR;fp[1]=R[10];fp[2]=R[11];R[12]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[10]=F(42);if(R[6]==R[10]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[11]=ob[1];R[12]=ob[2];}*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[12];R[3]=(word)fp;fp+=4;R[4]=R[11];ob=(word *)R[5];acc=3;}else{R[11]=G(R[1],3);R[12]=G(R[1],4);R[6]=IFALSE;R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=4;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1014:if(acc==1){if(R[3]==F(0)){R[4]=G(R[1],2);ob=(word *)R[4];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}if(R[4]==F(0)){R[5]=F(32);R[3]=prim_cast((word *)R[3],fixval(R[5])&63);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[5]=F(41);R[3]=prim_cast((word *)R[3],fixval(R[5])&63);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1015:if(acc==1){{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}if(R[4]==F(0)){R[5]=F(32);R[3]=prim_cast((word *)R[3],fixval(R[5])&63);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[5]=F(41);R[3]=prim_cast((word *)R[3],fixval(R[5])&63);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1016:if(acc==5){R[8]=G(R[4],1);{word r=(fixval(R[8])|(1< */ + case 1017:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==IFALSE){R[5]=G(R[1],2);if(R[5]==F(0)){R[6]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[6]=INULL;*fp=NUMHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}}else{R[5]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}}else{R[4]=G(R[1],2);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],4);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1018:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){R[7]=G(R[1],2);if(R[4]==R[7]){R[8]=G(R[1],3);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(1);{word res=fixval(R[4])+fixval(R[8]);R[10]=BOOL(res&(1< */ + case 1019:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=F(32);if(R[5]==R[6]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(40);if(R[5]==R[7]){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(41);if(R[5]==R[8]){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=F(42);if(R[5]==R[9]){R[10]=G(R[4],1);{word ob=R[10];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==F(0)){R[12]=IFALSE;ob=(word *)R[3];R[3]=R[12];acc=1;}else{if(R[11]==R[6]){R[12]=ITRUE;ob=(word *)R[3];R[3]=R[12];acc=1;}else{if(R[11]==R[7]){R[12]=IFALSE;ob=(word *)R[3];R[3]=R[12];acc=1;}else{if(R[11]==R[8]){R[12]=ITRUE;ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[12]=G(R[1],2);R[13]=G(R[1],3);R[5]=R[4];R[4]=R[13];ob=(word *)R[12];acc=3;}}}}}else{R[10]=G(R[1],2);R[11]=G(R[1],4);R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=3;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1020:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}if(R[5]==F(0)){R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=F(32);if(R[5]==R[6]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(40);if(R[5]==R[7]){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(41);if(R[5]==R[8]){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=F(42);if(R[5]==R[9]){R[10]=ITRUE;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[10]=F(43);if(R[5]==R[10]){R[11]=ITRUE;ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[11]=IFALSE;ob=(word *)R[3];R[3]=R[11];acc=1;}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1021:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=(R[4]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(32);if(R[7]==R[8]){R[9]=(R[4]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=F(40);if(R[7]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==R[9]){R[11]=G(R[1],2);ob=(word *)R[11];acc=3;}else{R[11]=IFALSE;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{R[10]=F(41);if(R[7]==R[10]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[11]=F((ob>>TPOS)&63);}if(R[11]==R[10]){R[12]=G(R[1],2);ob=(word *)R[12];acc=3;}else{R[12]=IFALSE;ob=(word *)R[3];R[3]=R[12];acc=1;}}else{R[11]=F(42);if(R[7]==R[11]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}if(R[12]==R[11]){R[13]=G(R[4],1);R[14]=G(R[5],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[13];R[5]=R[14];ob=(word *)R[6];acc=4;}else{R[13]=IFALSE;ob=(word *)R[3];R[3]=R[13];acc=1;}}else{R[12]=F(43);if(R[7]==R[12]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[13]=F((ob>>TPOS)&63);}if(R[13]==R[12]){R[14]=F(1);R[15]=prim_ref(R[4],R[14]);R[16]=prim_ref(R[5],R[14]);*fp=make_header(6,TPROC);fp[1]=G(R[1],4);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[15];R[5]=R[16];ob=(word *)R[6];acc=4;}else{R[14]=IFALSE;ob=(word *)R[3];R[3]=R[14];acc=1;}}else{R[13]=G(R[1],5);R[14]=G(R[1],6);R[6]=R[5];R[5]=R[4];R[4]=R[14];ob=(word *)R[13];acc=4;}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1022:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}if(R[6]==F(0)){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=prim_less(R[4],R[5]);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(40);if(R[7]==R[8]){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}}}else{R[7]=F(32);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==F(0)){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{if(R[8]==R[7]){if(R[4]==R[5]){R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=prim_less(R[5],R[4]);ob=(word *)R[3];R[3]=R[9];acc=1;}}else{R[9]=F(40);if(R[8]==R[9]){R[10]=ITRUE;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[10]=IFALSE;ob=(word *)R[3];R[3]=R[10];acc=1;}}}}else{R[8]=F(40);if(R[6]==R[8]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}if(R[9]==R[8]){R[10]=G(R[1],2);R[6]=IFALSE;ob=(word *)R[10];acc=4;}else{R[10]=IFALSE;ob=(word *)R[3];R[3]=R[10];acc=1;}}else{R[9]=F(41);if(R[6]==R[9]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}if(R[10]==R[9]){R[11]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=IFALSE;ob=(word *)R[11];acc=4;}else{R[11]=ITRUE;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{R[10]=G(R[1],4);R[11]=G(R[1],5);R[6]=R[5];R[5]=R[4];R[4]=R[11];ob=(word *)R[10];acc=4;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1023:if(acc==4){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}if(R[7]==F(0)){R[8]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[5]=IFALSE;R[6]=G(R[1],4);ob=(word *)R[8];acc=4;}else{R[8]=G(R[1],5);ob=(word *)R[8];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1024:if(acc==4){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(32);if(R[7]==R[8]){R[9]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=F(41);if(R[9]==R[10]){R[11]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],4);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[11];acc=2;}else{R[11]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[1],6);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[11];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1025:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[4];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1026:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=4;R[6]=G(R[1],3);R[4]=G(R[1],2);R[3]=R[6];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1027:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[5];fp[4]=R[3];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1028:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[2],4);R[8]=R[4];R[4]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],5);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1029:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[2],4);R[8]=R[4];R[4]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],3);R[3]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1030:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],3);R[3]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1031:if(acc==2){R[5]=F(12);R[6]=IFALSE;R[7]=prim_sys(fixval(R[5]), R[4], R[6], R[6]);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1032:if(acc==1){R[4]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=4;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[6]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[7]=(word)fp;fp+=3;R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1033:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=F(11);R[5]=G(R[1],2);R[6]=IFALSE;R[3]=prim_sys(fixval(R[4]), R[5], R[6], R[6]);R[8]=G(R[1],3);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1034:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=INULL;R[9]=R[5];R[3]=R[6];R[6]=R[4];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1035:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;R[5]=G(R[1],4);R[9]=IFALSE;R[10]=R[6];R[3]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1036:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[7];acc=1;}else{R[8]=G(R[2],3);R[5]=G(R[2],4);R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1037:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[2],4);R[6]=IFALSE;R[11]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1038:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1039:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[9];acc=1;}else{R[3]=G(R[2],3);ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1040:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[11]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1041:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],6);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[10]=(word)fp;fp+=8;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[10];acc=1;}else{R[11]=G(R[2],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[10];R[3]=(word)fp;fp+=3;R[5]=G(R[2],5);R[6]=IFALSE;ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1042:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[12];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1043:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],6);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[11]=(word)fp;fp+=9;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[11];acc=1;}else{R[12]=G(R[2],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[11];R[3]=(word)fp;fp+=3;R[5]=G(R[2],5);R[6]=IFALSE;ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1044:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[13]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1045:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],4);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[12]=(word)fp;fp+=10;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[12];acc=1;}else{R[3]=G(R[2],3);ob=(word *)R[12];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1046:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=11;R[14]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[14];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1047:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=11;R[14]=G(R[1],2);R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[14];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1048:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],4);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[13]=(word)fp;fp+=11;if(R[3]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[13];acc=1;}else{R[3]=G(R[2],3);ob=(word *)R[13];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1049:if(acc==1){R[4]=G(R[2],5);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[13]=(word)fp;fp+=3;R[14]=G(R[1],5);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[13];R[15]=(word)fp;fp+=3;R[16]=G(R[1],6);*fp=PAIRHDR;fp[1]=R[16];fp[2]=R[15];R[17]=(word)fp;fp+=3;R[18]=G(R[1],7);*fp=PAIRHDR;fp[1]=R[18];fp[2]=R[17];R[19]=(word)fp;fp+=3;R[20]=G(R[1],8);*fp=PAIRHDR;fp[1]=R[20];fp[2]=R[19];R[21]=(word)fp;fp+=3;R[22]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[22];fp[2]=R[21];R[6]=(word)fp;fp+=3;R[24]=G(R[2],2);R[3]=G(R[1],10);R[4]=G(R[2],3);R[5]=G(R[1],9);ob=(word *)R[24];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1050:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=G(R[2],2);R[3]=G(R[1],2);R[4]=G(R[2],3);R[5]=G(R[2],4);R[6]=R[7];ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1051:if(acc==5){R[8]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[6]=G(R[1],4);R[7]=INULL;R[12]=R[5];R[5]=R[4];R[4]=R[12];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1052:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];}R[6]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1053:if(acc==6){if(R[5]==INULL){R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[5]=R[4];R[4]=R[6];ob=(word *)R[9];acc=3;}else{assert(pairp(R[5]),R[5],1052);R[9]=G(R[5],1);R[10]=G(R[1],4);*fp=make_header(8,TCLOS);fp[1]=G(R[1],5);fp[7]=R[8];fp[6]=R[3];fp[5]=R[4];fp[4]=R[6];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[4]=R[9];ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1054:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],7);R[3]=G(R[1],6);R[4]=G(R[1],5);R[6]=G(R[1],4);R[7]=R[8];R[8]=R[9];ob=(word *)R[8];acc=6;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[13]=G(R[2],4);R[4]=R[5];R[5]=R[13];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1055:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=R[5];R[5]=R[9];ob=(word *)R[6];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],4);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1056:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=INULL;R[8]=G(R[1],2);R[11]=R[6];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[4];R[4]=R[11];R[3]=R[12];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1057:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=R[5];ob=(word *)R[6];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],5);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[11]=(word)fp;fp+=9;R[5]=G(R[2],6);R[6]=IFALSE;R[9]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1058:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=10;R[5]=G(R[2],4);R[14]=IFALSE;R[9]=R[4];R[4]=R[6];R[6]=R[14];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1059:if(acc==1){R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[2],2);R[4]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[6];fp[4]=R[9];fp[3]=R[4];fp[2]=R[3];R[13]=(word)fp;fp+=9;R[6]=F(0);R[5]=R[3];R[3]=R[13];ob=(word *)R[7];acc=4;}else{R[5]=G(R[1],3);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);if(R[6]==INULL){R[7]=G(R[5],1);R[8]=G(R[2],6);R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[10]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[10];R[11]=(word)fp;fp+=3;R[12]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[4]=(word)fp;fp+=3;R[14]=G(R[2],4);R[3]=G(R[1],8);ob=(word *)R[14];acc=2;}else{R[7]=G(R[2],7);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);R[13]=G(R[1],9);*fp=make_header(11,TCLOS);fp[1]=G(R[2],8);fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[8];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=11;R[4]=R[5];ob=(word *)R[7];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1060:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);*fp=make_header(10,TCLOS);fp[1]=G(R[2],2);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[13]=(word)fp;fp+=10;R[7]=R[4];R[4]=R[3];R[3]=R[13];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1061:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);*fp=make_header(11,TCLOS);fp[1]=G(R[2],3);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=11;R[5]=G(R[2],4);R[15]=G(R[2],5);R[9]=R[4];R[4]=R[6];R[6]=R[15];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1062:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);R[12]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],2);fp[10]=R[12];fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[13]=(word)fp;fp+=11;R[7]=R[3];R[4]=R[6];R[3]=R[13];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1063:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],9);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);R[13]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],5);fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=11;R[5]=G(R[2],6);R[16]=IFALSE;R[9]=R[4];R[4]=R[6];R[6]=R[16];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1064:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);R[11]=G(R[1],10);*fp=make_header(10,TCLOS);fp[1]=G(R[2],4);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[12]=(word)fp;fp+=10;if(R[3]==IFALSE){R[13]=G(R[2],2);R[4]=G(R[1],2);R[3]=R[12];ob=(word *)R[13];acc=2;}else{R[13]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[12];R[3]=(word)fp;fp+=3;R[4]=G(R[1],2);ob=(word *)R[13];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1065:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[13]=G(R[1],2);R[5]=G(R[2],4);R[6]=IFALSE;R[9]=R[4];R[4]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1066:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],4);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[11]=(word)fp;fp+=9;if(R[3]==IFALSE){R[3]=G(R[1],2);ob=(word *)R[11];acc=1;}else{R[12]=G(R[2],2);R[13]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[11];fp[2]=R[13];R[3]=(word)fp;fp+=4;R[6]=INULL;R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1067:if(acc==1){R[4]=G(R[1],2);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],3);R[4]=R[3];R[5]=R[6];R[3]=R[8];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1068:if(acc==1){R[4]=G(R[2],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1069:if(acc==1){R[4]=G(R[2],5);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=G(R[2],3);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[4]=(word)fp;fp+=3;R[14]=G(R[2],2);R[3]=G(R[1],3);ob=(word *)R[14];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1070:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[6]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1071:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[13]=G(R[2],4);R[4]=R[5];R[5]=R[13];ob=(word *)R[6];acc=3;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],5);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],6);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[12]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[12];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1072:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],3);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[4]=(word)fp;fp+=3;R[10]=G(R[2],2);R[3]=G(R[1],6);ob=(word *)R[10];acc=2;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],7);R[3]=G(R[1],6);R[4]=G(R[1],5);R[6]=G(R[1],4);R[7]=R[8];R[8]=R[9];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1073:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1074:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,2);fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1075:if(acc==2){if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[6]=F(1);R[7]=prim_less(R[5],R[6]);if(R[7]==IFALSE){R[8]=F(0);R[9]=prim_ref(R[4],R[8]);R[10]=F(45);R[11]=(R[10]==R[9])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1076:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[8]=G(R[1],4);R[9]=IFALSE;R[10]=R[6];R[4]=R[5];R[3]=R[7];R[5]=R[8];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1077:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[9]=R[4];R[5]=R[3];R[4]=R[6];R[3]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1078:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{R[9]=G(R[2],2);R[5]=G(R[2],3);R[3]=R[8];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1079:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1080:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[10]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1081:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1082:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1083:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;if(R[3]==IFALSE){R[3]=G(R[1],2);ob=(word *)R[7];acc=1;}else{R[8]=G(R[1],2);R[9]=INULL;*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[9];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1084:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[9]=G(R[2],4);R[10]=IFALSE;R[11]=R[6];R[4]=R[5];R[5]=R[9];R[6]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1085:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[2],4);R[6]=IFALSE;R[12]=R[4];R[4]=R[7];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1086:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[5]=G(R[2],4);R[9]=G(R[2],5);R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{R[4]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1087:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],6);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[9];R[3]=(word)fp;fp+=3;R[4]=G(R[2],4);R[5]=G(R[2],5);R[6]=R[7];ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1088:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[7]=(word)fp;fp+=3;R[8]=G(R[1],4);R[9]=R[6];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1089:if(acc==1){R[4]=G(R[2],2);R[3]=(R[4]==R[3])?ITRUE:IFALSE;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1090:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1091:if(acc==1){assert(pairp(R[3]),R[3],1053);R[4]=G(R[3],2);R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[2],3);R[8]=R[5];R[5]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1092:if(acc==2){R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(45);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[4]=(word)fp;fp+=3;R[9]=G(R[1],2);ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1093:if(acc==4){if(R[5]==INULL){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[5]=G(R[1],4);R[6]=IFALSE;R[4]=R[7];ob=(word *)R[8];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1094:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[8]=R[4];R[5]=R[3];R[4]=R[7];R[3]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1095:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],5);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;if(R[3]==IFALSE){R[10]=G(R[2],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[5]=G(R[2],4);R[6]=IFALSE;ob=(word *)R[10];acc=4;}else{ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1096:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],6);R[7]=G(R[1],5);R[4]=G(R[1],4);R[3]=R[7];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1097:if(acc==2){R[5]=F(0);R[4]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[1],2);ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1098:if(acc==4){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=INULL;R[5]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1099:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[7];fp[6]=R[3];fp[5]=R[6];fp[4]=R[5];fp[3]=R[4];fp[2]=R[9];R[3]=(word)fp;fp+=8;R[5]=F(0);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1100:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],6);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1101:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1102:if(acc==3){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[6]=G(R[1],2);R[7]=INULL;R[9]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1103:if(acc==5){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[8]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[10]=G(R[1],4);R[6]=INULL;R[7]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[8];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1104:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=G(R[2],4);R[8]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1105:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=R[4];R[11]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[7]=R[9];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1106:if(acc==6){if(R[5]==INULL){R[7]=R[3];R[3]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[1],3);fp[7]=R[7];fp[6]=R[3];fp[5]=R[8];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[4]=R[5];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1107:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[3];R[11]=(word)fp;fp+=3;R[5]=G(R[1],2);R[8]=R[4];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1108:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],2);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1109:if(acc==2){assert(pairp(R[3]),R[3],1053);R[5]=G(R[3],2);if(R[5]==INULL){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],6);R[9]=G(R[1],3);R[10]=G(R[1],5);R[11]=G(R[1],4);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[4];fp[3]=R[8];fp[2]=R[7];R[12]=(word)fp;fp+=8;R[4]=R[3];R[3]=R[12];ob=(word *)R[6];acc=2;}else{R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],4);fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[9]=(word)fp;fp+=5;R[10]=G(R[1],3);R[11]=G(R[1],2);R[5]=R[4];R[7]=R[8];R[8]=R[6];R[3]=R[9];R[4]=R[10];R[6]=R[11];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1110:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[2],4);R[10]=G(R[1],2);R[11]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1111:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],7);R[7]=G(R[1],6);R[8]=G(R[1],5);R[9]=G(R[1],4);R[10]=G(R[1],3);R[4]=R[8];R[8]=R[6];R[6]=R[5];R[3]=R[7];R[5]=R[9];R[7]=R[10];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1112:if(acc==3){assert(pairp(R[4]),R[4],1052);R[6]=G(R[4],1);assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=prim_less(R[6],R[7]);ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1113:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[5]=F(0);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1114:if(acc==2){R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],4);R[3]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1115:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1116:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[5]=(word)fp;fp+=3;R[9]=G(R[2],2);R[3]=G(R[1],5);R[4]=G(R[2],3);ob=(word *)R[9];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[6];R[4]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1117:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=F(0);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1118:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],4);R[3]=F(0);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1119:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1120:if(acc==4){R[7]=G(R[1],2);R[8]=F(0);R[9]=INULL;R[11]=R[7];R[7]=R[8];R[8]=R[9];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1121:if(acc==7){if(R[5]==INULL){R[10]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[8];ob=(word *)R[10];acc=2;}else{R[10]=G(R[1],4);*fp=make_header(9,TCLOS);fp[1]=G(R[1],5);fp[8]=R[3];fp[7]=R[4];fp[6]=R[5];fp[5]=R[6];fp[4]=R[8];fp[3]=R[9];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[6];R[5]=R[7];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1122:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],6);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=F(1);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1123:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[11]=R[4];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[8]=R[9];R[3]=R[12];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1124:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],2);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],2);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],4);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[5];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=G(R[1],2);R[5]=F(1);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1125:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[13]=G(R[1],3);R[4]=R[5];R[5]=R[13];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1126:if(acc==7){if(R[5]==INULL){R[10]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[8];ob=(word *)R[10];acc=2;}else{R[10]=G(R[1],4);*fp=make_header(9,TCLOS);fp[1]=G(R[1],5);fp[8]=R[9];fp[7]=R[3];fp[6]=R[6];fp[5]=R[7];fp[4]=R[5];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[10];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1127:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],2);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],2);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[5]=R[7];R[4]=R[12];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1128:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=10;R[8]=R[5];R[5]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1129:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[10]=(word)fp;fp+=8;if(R[3]==IFALSE){R[3]=G(R[1],3);ob=(word *)R[10];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[6]=G(R[4],1);R[12]=G(R[2],2);R[4]=G(R[1],3);R[5]=G(R[1],2);R[3]=R[10];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1130:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1131:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[6];R[13]=R[5];R[5]=R[3];R[6]=R[7];R[7]=R[8];R[8]=R[9];R[9]=R[4];R[4]=R[12];R[3]=R[13];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1132:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1133:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1134:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1135:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1136:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],3);R[5]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[6]=G(R[2],4);R[7]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],5);fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1137:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=5;R[9]=F(1);R[10]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1138:if(acc==1){R[4]=G(R[1],2);R[5]=prim_ref(R[4],R[3]);R[6]=G(R[1],4);R[3]=G(R[1],3);R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1139:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[2],3);R[7]=G(R[1],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1140:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1141:if(acc==1){R[4]=F(2);R[5]=prim_ref(R[3],R[4]);R[6]=G(R[5],1);R[7]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[3];R[8]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[8];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1142:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[5]=G(R[1],2);R[9]=INULL;R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1143:if(acc==1){R[4]=IFALSE;R[5]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[4];fp[2]=R[5];fp[3]=R[3];R[3]=(word)fp;fp+=4;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1144:if(acc==1){R[4]=ITRUE;R[5]=G(R[1],2);*fp=make_header(4,2);fp[1]=R[4];fp[2]=R[3];fp[3]=R[5];R[3]=(word)fp;fp+=4;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1145:if(acc==5){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[8]=G(R[5],1);R[9]=G(R[1],2);{uint64_t res=(uint64_t) (((uint64_t) fixval(R[8]))*((uint64_t)fixval(R[9])));R[10]=F((word)(res&FMAX));R[11]=F((word)(res>>FBITS));}{word res=fixval(R[10])+fixval(R[4]);R[13]=BOOL(res&(1< */ + case 1146:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}*fp=NUMHDR;fp[1]=R[7];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[4]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1147:if(acc==1){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1148:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1149:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[5];R[5]=R[7];R[7]=R[9];R[9]=R[4];R[4]=R[6];R[6]=R[8];R[8]=R[3];R[3]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1150:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1151:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(10);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1152:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=IFALSE;R[11]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[8]=R[7];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1153:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[9]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1154:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[10];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1155:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=10;R[4]=F(0);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1156:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],9);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[13]=(word)fp;fp+=10;*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[9];R[14]=(word)fp;fp+=3;R[8]=R[4];R[5]=R[3];R[3]=R[13];R[4]=R[14];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1157:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[5];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=F(46);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1158:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[4];fp[5]=R[5];fp[4]=R[7];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[4]=R[6];R[5]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1159:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[1],2);R[7]=R[4];R[4]=R[12];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1160:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=10;R[4]=G(R[1],2);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1161:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[4];fp[5]=R[5];fp[4]=R[7];fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=9;R[4]=G(R[1],3);R[5]=G(R[1],2);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1162:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1163:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TPROC);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[9]=(word)fp;fp+=7;R[10]=F(43);if(R[6]==R[10]){R[3]=G(R[2],2);ob=(word *)R[9];acc=1;}else{R[3]=G(R[2],3);ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1164:if(acc==2){R[5]=G(R[1],2);R[6]=F(0);R[8]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1165:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=F(1);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1166:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[7];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1167:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[5];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=F(101);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1168:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=R[9];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1169:if(acc==5){R[8]=G(R[1],3);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[9]=(word)fp;fp+=7;R[10]=G(R[1],2);R[11]=F(43);if(R[10]==R[11]){R[3]=R[6];ob=(word *)R[9];acc=1;}else{R[12]=G(R[2],2);R[4]=F(0);R[5]=R[6];R[3]=R[9];ob=(word *)R[12];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1170:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[5];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=R[9];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1171:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[5]=G(R[1],2);R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1172:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[5];R[7]=(word)fp;fp+=3;R[5]=F(0);R[9]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1173:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=G(R[2],4);R[10]=IFALSE;R[11]=R[6];R[6]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1174:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[9]=(word)fp;fp+=7;if(R[3]==IFALSE){R[10]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[9];R[3]=(word)fp;fp+=3;R[4]=R[7];ob=(word *)R[10];acc=3;}else{ob=(word *)R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1175:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],4);R[5]=G(R[1],3);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],6);R[6]=G(R[2],5);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1176:if(acc==2){R[5]=F(10);if(R[4]==R[5]){R[6]=G(R[1],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[4];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1177:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[6]=F(100);R[10]=R[5];R[5]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1178:if(acc==2){R[5]=G(R[1],2);R[6]=F(48);R[7]=F(57);R[9]=R[5];R[5]=R[4];R[4]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1179:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1180:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1181:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[10]=(word)fp;fp+=6;R[6]=G(R[1],3);R[7]=G(R[1],2);R[13]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[13];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1182:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1183:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[6]=G(R[1],3);R[7]=G(R[1],2);R[12]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[12];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1184:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[6]=G(R[1],3);R[7]=G(R[1],2);R[11]=R[3];R[3]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[11];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1185:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=8;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1186:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],2);R[7]=R[4];R[4]=R[11];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],2);R[7]=R[4];R[4]=R[11];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1187:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],6);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[10]=G(R[1],2);R[11]=R[4];R[4]=R[3];R[3]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];R[8]=R[10];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1188:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[11]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];R[8]=R[9];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1189:if(acc==6){*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[6];fp[4]=R[7];fp[3]=R[8];fp[2]=R[5];R[5]=(word)fp;fp+=6;ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1190:if(acc==3){if(R[4]==INULL){R[6]=INULL;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[3];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=9;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1191:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],8);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1192:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);if(R[4]==IFALSE){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[4]=G(R[5],2);R[5]=G(R[1],3);R[9]=G(R[1],7);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[9];fp[2]=R[6];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=3;}else{R[5]=G(R[1],7);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}}else{{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];R[6]=ob[3];}R[7]=G(R[2],3);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[12];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=8;R[14]=G(R[2],5);R[4]=R[6];R[6]=R[5];R[5]=R[14];ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1193:if(acc==1){R[4]=G(R[1],5);if(R[4]==IFALSE){R[5]=G(R[1],4);if(R[5]==IFALSE){R[6]=G(R[2],2);R[7]=G(R[1],7);R[4]=G(R[1],6);R[9]=G(R[1],3);R[10]=R[6];R[5]=R[3];R[3]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{R[6]=G(R[1],2);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);R[5]=R[6];ob=(word *)R[5];acc=3;}}else{R[5]=G(R[2],2);R[6]=G(R[1],7);R[7]=G(R[1],6);R[8]=G(R[1],3);R[9]=R[5];R[5]=R[3];R[3]=R[6];R[4]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1194:if(acc==4){R[7]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[5];R[8]=(word)fp;fp+=3;R[5]=R[6];R[6]=R[4];R[4]=R[8];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1195:if(acc==3){R[6]=F(92);if(R[4]==R[6]){if(R[5]==INULL){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=F(47);R[9]=prim_less(R[8],R[7]);R[10]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[3];fp[4]=R[5];fp[3]=R[10];fp[2]=R[7];R[11]=(word)fp;fp+=6;if(R[9]==IFALSE){R[3]=IFALSE;ob=(word *)R[11];acc=1;}else{R[12]=F(58);R[3]=prim_less(R[7],R[12]);ob=(word *)R[11];acc=1;}}}else{*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1196:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=F(92);if(R[4]==R[5]){R[6]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[6];acc=1;}}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(48);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1197:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1198:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=5;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1199:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=INULL;R[10]=R[4];R[11]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[7]=R[8];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1200:if(acc==6){if(R[5]==INULL){R[9]=G(R[1],2);R[4]=R[7];ob=(word *)R[9];acc=2;}else{R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[1],4);fp[7]=R[3];fp[6]=R[6];fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[4]=R[5];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1201:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],6);R[7]=G(R[1],4);R[8]=G(R[1],7);R[9]=G(R[1],5);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],3);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1202:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);if(R[4]==IFALSE){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[5],1);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[8]=G(R[1],5);R[3]=G(R[1],7);R[12]=G(R[1],4);R[5]=R[6];R[6]=R[4];R[7]=R[9];R[4]=R[12];ob=(word *)R[8];acc=6;}else{R[5]=G(R[1],2);R[6]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=3;R[8]=G(R[1],7);ob=(word *)R[8];acc=1;}}else{{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];R[6]=ob[3];}R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1203:if(acc==1){R[4]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=4;R[6]=G(R[1],5);if(R[6]==IFALSE){R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[6]=IFALSE;R[11]=INULL;R[3]=R[5];R[4]=R[8];R[8]=R[7];R[5]=R[9];R[7]=R[11];ob=(word *)R[8];acc=6;}else{R[7]=G(R[1],2);R[8]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[3]=(word)fp;fp+=3;ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1204:if(acc==2){if(R[4]==INULL){R[5]=INULL;ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1205:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1206:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[1],3);R[3]=R[4];ob=(word *)R[5];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}}else{R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1207:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1208:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[2],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1209:if(acc==4){if(R[5]==INULL){R[7]=G(R[1],2);ob=(word *)R[7];acc=3;}else{R[7]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1210:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],3);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1211:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[4]=G(R[1],3);R[3]=R[7];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],4);R[3]=ITRUE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1212:if(acc==4){*fp=make_header(4,2);fp[1]=R[4];fp[2]=R[5];fp[3]=R[6];R[7]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1213:if(acc==3){R[6]=INULL;R[7]=G(R[1],2);R[8]=G(R[1],3);R[10]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1214:if(acc==4){if(R[4]==INULL){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);assert(pairp(R[7]),R[7],1052);R[8]=G(R[7],1);if(R[5]==R[8]){R[9]=G(R[7],2);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[4]=G(R[4],2);ob=(word *)R[6];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1215:if(acc==4){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1216:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[7];fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[4]=R[6];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1217:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=F(1);R[8]=R[4];R[5]=R[3];R[3]=R[11];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1218:if(acc==1){R[4]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],6);R[3]=G(R[1],5);R[10]=G(R[1],4);R[11]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[11];fp[2]=R[5];R[12]=(word)fp;fp+=4;R[5]=R[4];R[6]=R[7];R[4]=R[10];R[7]=R[12];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1219:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],3);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[4]=R[6];R[6]=R[5];R[5]=R[10];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1220:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1221:if(acc==5){assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);if(R[5]==R[8]){assert(pairp(R[5]),R[5],1052);R[9]=G(R[5],1);R[5]=G(R[5],2);R[11]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[9];R[3]=(word)fp;fp+=5;R[13]=INULL;R[4]=R[6];R[6]=R[13];ob=(word *)R[11];acc=4;}else{R[9]=G(R[4],1);R[4]=G(R[4],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1222:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);assert(pairp(R[6]),R[6],1053);R[7]=G(R[6],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[9]=G(R[1],4);ob=(word *)R[9];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1223:if(acc==5){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[8]=G(R[4],2);R[9]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[4]=R[8];ob=(word *)R[7];acc=5;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1224:if(acc==5){R[8]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1225:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],3);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[5]=F(1);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1226:if(acc==5){R[8]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[8];fp[2]=R[6];R[7]=(word)fp;fp+=5;ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1227:if(acc==5){R[8]=G(R[1],3);R[9]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[3];fp[5]=R[9];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[6]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[7];R[7]=(word)fp;fp+=3;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1228:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[5]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{R[4]=G(R[1],6);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1229:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[9];fp[2]=R[7];R[7]=(word)fp;fp+=4;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1230:if(acc==4){R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1231:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],2);fp[7]=R[3];fp[6]=R[9];fp[5]=R[4];fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=8;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1232:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],7);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[10]=G(R[1],2);R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}else{R[4]=G(R[1],7);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1233:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],6);R[3]=G(R[1],5);R[6]=G(R[1],4);R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1234:if(acc==5){if(R[4]==INULL){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=G(R[2],2);R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[7];fp[7]=R[3];fp[6]=R[6];fp[5]=R[5];fp[4]=R[4];fp[3]=R[10];fp[2]=R[9];R[3]=(word)fp;fp+=9;ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1235:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],4);R[6]=G(R[1],8);R[7]=G(R[1],6);R[8]=G(R[1],5);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=R[4];R[4]=R[11];ob=(word *)R[5];acc=3;}else{R[4]=G(R[1],4);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],3);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(7,TPROC);fp[1]=G(R[2],4);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=G(R[1],3);R[13]=IFALSE;R[9]=R[6];R[6]=R[13];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1236:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1237:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1238:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],6);R[3]=G(R[1],5);R[6]=G(R[1],4);R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1239:if(acc==6){if(R[4]==INULL){R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[2],2);R[10]=G(R[1],2);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[7];fp[7]=R[3];fp[6]=R[6];fp[5]=R[10];fp[4]=R[5];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=9;ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1240:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],8);R[6]=G(R[1],6);R[7]=G(R[1],4);R[8]=G(R[1],7);R[9]=G(R[1],2);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],5);if(R[5]==R[6]){R[7]=G(R[4],2);R[8]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[1],8);R[3]=G(R[1],7);R[6]=G(R[1],6);R[4]=R[7];ob=(word *)R[10];acc=4;}else{R[7]=G(R[1],7);R[3]=IFALSE;ob=(word *)R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1241:if(acc==6){if(R[4]==INULL){ob=(word *)R[7];acc=4;}else{R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[1],3);fp[7]=R[8];fp[6]=R[3];fp[5]=R[5];fp[4]=R[6];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1242:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1243:if(acc==5){ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1244:if(acc==6){R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[5];fp[2]=R[6];R[6]=(word)fp;fp+=6;R[7]=F(0);R[12]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[12];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1245:if(acc==3){R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],5);fp[3]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=4;R[8]=G(R[1],4);if(R[8]==IFALSE){R[3]=IFALSE;ob=(word *)R[7];acc=1;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[7];fp[5]=R[8];fp[4]=R[10];fp[3]=R[4];fp[2]=R[9];R[11]=(word)fp;fp+=7;if(R[9]==IFALSE){R[12]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[11];R[3]=(word)fp;fp+=3;R[4]=R[10];ob=(word *)R[12];acc=2;}else{R[3]=R[9];ob=(word *)R[11];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1246:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],3);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;R[9]=G(R[1],2);if(R[9]==IFALSE){R[10]=G(R[2],4);if(R[10]==IFALSE){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{R[3]=R[10];ob=(word *)R[8];acc=1;}}else{R[3]=R[9];ob=(word *)R[8];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1247:if(acc==5){R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[5];fp[4]=R[3];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1248:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[2],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1249:if(acc==3){if(R[4]==INULL){R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1250:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=F(10);if(R[5]==R[6]){R[7]=G(R[1],3);R[3]=ITRUE;ob=(word *)R[7];acc=1;}else{R[4]=G(R[4],2);R[5]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[5];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1251:if(acc==5){*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[5];fp[3]=R[7];fp[2]=R[4];R[8]=(word)fp;fp+=5;R[9]=F(1);R[10]=F(0);R[7]=INULL;R[5]=R[6];R[4]=R[9];R[6]=R[10];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1252:if(acc==6){if(R[5]==INULL){R[9]=G(R[2],6);R[10]=INULL;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[11];R[12]=(word)fp;fp+=3;R[13]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[14]=(word)fp;fp+=3;R[15]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[15];fp[2]=R[14];R[5]=(word)fp;fp+=3;R[17]=G(R[2],2);R[18]=G(R[1],3);R[19]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[19];fp[4]=R[6];fp[3]=R[18];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[2],4);ob=(word *)R[17];acc=3;}else{R[9]=G(R[2],7);R[10]=G(R[1],2);R[11]=G(R[1],3);R[12]=G(R[1],4);*fp=make_header(11,TCLOS);fp[1]=G(R[2],8);fp[10]=R[8];fp[9]=R[3];fp[8]=R[6];fp[7]=R[5];fp[6]=R[12];fp[5]=R[11];fp[4]=R[7];fp[3]=R[10];fp[2]=R[4];R[3]=(word)fp;fp+=11;R[4]=R[5];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1253:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[5]=G(R[1],4);R[6]=G(R[1],8);R[7]=G(R[1],2);R[8]=G(R[1],9);R[9]=G(R[1],10);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],7);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],3);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],8);R[13]=G(R[1],9);R[14]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],4);fp[10]=R[14];fp[9]=R[13];fp[8]=R[12];fp[7]=R[4];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=11;R[16]=F(10);R[4]=R[5];R[5]=R[16];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1254:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],2);R[9]=G(R[1],9);R[10]=G(R[1],10);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[5];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=8;R[4]=G(R[1],8);R[5]=F(1);ob=(word *)R[6];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);R[12]=G(R[1],9);R[13]=G(R[1],10);*fp=make_header(11,TCLOS);fp[1]=G(R[2],5);fp[10]=R[13];fp[9]=R[12];fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=11;R[9]=R[4];R[4]=R[8];R[5]=R[11];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1255:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],6);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=G(R[2],5);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[5]=(word)fp;fp+=3;R[13]=G(R[2],2);R[14]=G(R[1],4);R[15]=G(R[1],5);R[16]=G(R[1],8);R[17]=G(R[1],6);R[18]=G(R[1],9);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[18];fp[5]=R[17];fp[4]=R[16];fp[3]=R[15];fp[2]=R[14];R[3]=(word)fp;fp+=7;R[4]=G(R[2],4);ob=(word *)R[13];acc=3;}else{R[4]=G(R[2],7);R[5]=G(R[1],7);R[6]=G(R[1],8);R[7]=G(R[1],9);R[8]=G(R[1],10);*fp=make_header(6,TCLOS);fp[1]=G(R[2],8);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=F(1);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1256:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=INULL;R[11]=R[5];R[5]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1257:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1258:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1259:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=F(1);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1260:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],7);R[9]=G(R[1],6);R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=R[3];R[3]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1261:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1262:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1263:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],4);R[5]=R[4];R[4]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1264:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[5]=G(R[2],5);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1265:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1266:if(acc==1){R[4]=F(96);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[4]=G(R[2],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1267:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=F(4);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1268:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(0);R[5]=F(1);R[9]=R[4];R[10]=R[6];R[6]=R[3];R[4]=R[7];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1269:if(acc==2){R[5]=F(32);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1270:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1271:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[7]=G(R[2],4);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1272:if(acc==5){R[8]=G(R[1],2);ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1273:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[1],2);R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1274:if(acc==5){R[8]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[5];R[5]=(word)fp;fp+=3;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1275:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[6];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[3]=(word)fp;fp+=8;R[4]=G(R[1],2);ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1276:if(acc==2){R[5]=G(R[1],2);R[6]=IFALSE;R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1277:if(acc==2){R[5]=G(R[1],2);R[6]=ITRUE;R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1278:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[5];fp[4]=R[6];fp[3]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=6;R[5]=INULL;R[6]=R[7];R[7]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1279:if(acc==5){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[5];R[9]=(word)fp;fp+=4;R[10]=G(R[1],3);R[11]=G(R[1],4);R[12]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[12];fp[6]=R[4];fp[5]=R[11];fp[4]=R[6];fp[3]=R[5];fp[2]=R[10];R[13]=(word)fp;fp+=8;R[7]=R[6];R[5]=R[9];R[6]=R[13];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1280:if(acc==3){R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(10,TCLOS);fp[1]=G(R[2],4);fp[9]=R[10];fp[8]=R[3];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[11]=(word)fp;fp+=10;R[12]=G(R[1],2);if(R[12]==IFALSE){R[13]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[11];R[3]=(word)fp;fp+=3;R[4]=R[6];ob=(word *)R[13];acc=2;}else{R[3]=R[12];ob=(word *)R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1281:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],8);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],2);R[7]=R[4];R[4]=R[11];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1282:if(acc==5){R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[10]=G(R[1],3);R[6]=R[7];R[7]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1283:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[6];fp[5]=R[9];fp[4]=R[4];fp[3]=R[5];fp[2]=R[7];R[6]=(word)fp;fp+=7;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1284:if(acc==3){R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[9];fp[3]=R[4];fp[2]=R[5];R[10]=(word)fp;fp+=5;R[11]=G(R[1],2);R[12]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[10];R[7]=R[11];ob=(word *)R[12];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1285:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=R[4];R[4]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1286:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1287:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1288:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[5];R[5]=(word)fp;fp+=4;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1289:if(acc==5){R[8]=G(R[1],3);if(R[6]==R[8]){R[9]=G(R[1],2);ob=(word *)R[9];acc=5;}else{R[9]=G(R[2],2);R[8]=R[5];R[4]=R[7];R[5]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1290:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[9];R[5]=(word)fp;fp+=4;ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1291:if(acc==5){R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],2);fp[7]=R[5];fp[6]=R[3];fp[5]=R[7];fp[4]=R[9];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[4]=R[6];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1292:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[2],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],4);R[5]=G(R[1],6);R[6]=G(R[1],3);R[7]=G(R[1],7);R[8]=G(R[1],2);R[9]=G(R[1],5);R[10]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1293:if(acc==2){*fp=make_header(3,TPROC);fp[1]=G(R[1],2);fp[2]=R[4];R[5]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1294:if(acc==5){R[8]=G(R[1],2);R[10]=R[5];R[5]=R[6];R[6]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1295:if(acc==6){if(R[4]==INULL){R[5]=G(R[1],2);R[4]=R[7];ob=(word *)R[6];acc=3;}else{R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[1],4);fp[7]=R[5];fp[6]=R[3];fp[5]=R[6];fp[4]=R[7];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=8;ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1296:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],7);R[8]=G(R[1],6);R[9]=G(R[1],2);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[2],3);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],4);fp[6]=R[10];fp[5]=R[9];fp[4]=R[5];fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=G(R[1],4);R[5]=F(1);ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1297:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[11]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1298:if(acc==3){if(R[4]==INULL){R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1299:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1300:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=R[5];R[3]=R[6];R[6]=R[4];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1301:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[4]=G(R[1],4);R[9]=G(R[1],5);R[10]=R[6];R[6]=R[5];R[3]=R[7];R[5]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1302:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(0);R[7]=INULL;R[8]=G(R[2],3);R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1303:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=F(0);R[7]=INULL;R[8]=G(R[1],2);R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1304:if(acc==3){R[6]=G(R[1],2);R[7]=F(0);R[8]=INULL;R[10]=R[6];R[11]=R[5];R[5]=R[7];R[7]=R[4];R[6]=R[8];R[4]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1305:if(acc==6){R[9]=G(R[1],2);if(R[5]==R[9]){R[10]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[3];fp[4]=R[8];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[10];acc=2;}else{if(R[4]==INULL){R[10]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[10];acc=2;}else{R[10]=F(1);{word res=fixval(R[5])+fixval(R[10]);R[12]=BOOL(res&(1< */ + case 1306:if(acc==1){R[4]=F(19);R[5]=IFALSE;R[6]=prim_lraw(R[3],fixval(R[4]),R[5]);R[7]=G(R[2],2);R[3]=G(R[1],3);R[5]=G(R[1],2);R[4]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1307:if(acc==1){R[4]=F(19);R[5]=IFALSE;R[6]=prim_lraw(R[3],fixval(R[4]),R[5]);R[7]=G(R[2],2);R[5]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1308:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=F(0);R[8]=INULL;R[9]=G(R[1],2);R[11]=R[6];R[6]=R[8];R[8]=R[4];R[3]=R[5];R[5]=R[7];R[7]=R[9];R[4]=R[11];ob=(word *)R[8];acc=6;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1309:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1310:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1311:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1312:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],2);R[3]=INULL;ob=(word *)R[5];acc=1;}else{*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1313:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;R[8]=F(4);R[9]=IFALSE;R[10]=R[6];R[5]=R[4];R[3]=R[7];R[4]=R[8];R[6]=R[9];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1314:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[5]=F(2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];}R[6]=G(R[2],5);R[7]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1315:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[6];fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=7;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1316:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==INULL){R[5]=G(R[1],5);R[6]=G(R[1],4);R[3]=R[4];R[4]=R[6];ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],3);R[7]=G(R[1],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],4);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1317:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[11]=G(R[1],2);R[4]=R[5];R[5]=R[11];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1318:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);if(immediatep(R[6])){R[7]=IFALSE;}else{word h=V(R[6]);R[7]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[8]=G(R[2],2);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[10];fp[3]=R[9];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=G(R[1],3);R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1319:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(3);R[8]=IFALSE;R[10]=R[5];R[5]=R[4];R[3]=R[6];R[4]=R[7];R[6]=R[8];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1320:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1321:if(acc==3){R[6]=G(R[1],2);R[7]=ITRUE;R[9]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1322:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[10]=F(5);R[7]=F(0);R[6]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[8];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1323:if(acc==1){R[4]=ITRUE;if(R[3]==R[4]){R[5]=G(R[1],2);if(R[5]==IFALSE){R[6]=G(R[1],5);ob=(word *)R[6];acc=1;}else{R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[4]=G(R[2],4);R[5]=F(5);ob=(word *)R[6];acc=3;}}else{R[5]=G(R[1],5);ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1324:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=ITRUE;R[3]=R[5];R[5]=R[7];R[7]=R[4];R[4]=R[6];R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1325:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(1);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1326:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(0);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1327:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1328:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[9]=R[5];R[5]=R[6];R[6]=R[7];R[4]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1329:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[3]=R[5];ob=(word *)R[4];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1330:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=F(15);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1331:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=F(0);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1332:if(acc==3){if(immediatep(R[4])){R[6]=IFALSE;}else{word h=V(R[4]);R[6]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[9]=F(1);R[4]=R[5];R[5]=R[9];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1333:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1334:if(acc==2){R[5]=G(R[1],2);R[6]=prim_ref(R[5],R[4]);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1335:if(acc==1){R[4]=F(19);R[5]=IFALSE;R[3]=prim_lraw(R[3],fixval(R[4]),R[5]);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1336:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=F(1);R[7]=G(R[1],2);R[8]=IFALSE;R[10]=R[4];R[11]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[7]=R[8];R[3]=R[11];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1337:if(acc==2){R[5]=G(R[1],2);R[6]=F(2);R[7]=IFALSE;R[10]=R[5];R[5]=R[4];R[4]=R[6];R[6]=R[7];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1338:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[3];R[7]=(word)fp;fp+=3;R[8]=ITRUE;R[9]=R[6];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1339:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1340:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[5];fp[4]=R[3];fp[3]=R[4];fp[2]=R[7];R[8]=(word)fp;fp+=6;if(R[6]==IFALSE){R[3]=G(R[2],2);ob=(word *)R[8];acc=1;}else{R[9]=G(R[2],3);R[3]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1341:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[8];R[6]=(word)fp;fp+=3;R[10]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1342:if(acc==3){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[6]=ob[1];R[7]=ob[2];}R[8]=F(1);if(R[7]==R[8]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[4];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1343:if(acc==1){R[4]=G(R[2],3);R[5]=G(R[1],2);R[6]=G(R[2],2);R[7]=F(1);R[10]=R[6];R[11]=R[5];R[5]=R[3];R[6]=R[7];R[7]=R[4];R[4]=R[10];R[3]=R[11];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1344:if(acc==5){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1345:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1346:if(acc==1){R[4]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],4);fp[2]=R[4];R[5]=(word)fp;fp+=3;if(R[3]==IFALSE){R[6]=G(R[2],2);R[4]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{ob=(word *)R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1347:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1348:if(acc==1){if(R[3]==IFALSE){R[4]=F(39);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1349:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1350:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],2);R[6]=(R[4]==R[5])?ITRUE:IFALSE;if(R[6]==IFALSE){R[7]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[7];acc=1;}else{R[7]=G(R[1],3);R[3]=R[6];ob=(word *)R[7];acc=1;}}else{R[4]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1351:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[4];R[5]=(word)fp;fp+=3;*fp=make_header(3,TPROC);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1352:if(acc==5){R[8]=G(R[2],2);R[9]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[6];fp[6]=R[4];fp[5]=R[3];fp[4]=R[5];fp[3]=R[7];fp[2]=R[9];R[3]=(word)fp;fp+=8;R[6]=IFALSE;ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1353:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);if(R[4]==INULL){R[5]=G(R[1],7);R[6]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[6];R[3]=(word)fp;fp+=3;R[4]=G(R[1],6);ob=(word *)R[5];acc=2;}else{R[5]=G(R[2],3);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=8;ob=(word *)R[5];acc=2;}}else{R[4]=G(R[2],5);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],6);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[10]=(word)fp;fp+=8;R[5]=F(0);R[8]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1354:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],6);R[9]=R[4];R[5]=R[8];R[4]=R[11];ob=(word *)R[9];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],3);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1355:if(acc==1){R[4]=F(35);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[7];R[5]=(word)fp;fp+=3;R[9]=G(R[2],2);R[10]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[10];R[11]=(word)fp;fp+=3;R[4]=R[3];R[3]=R[11];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1356:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],4);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[9];fp[3]=R[8];fp[2]=R[5];R[6]=(word)fp;fp+=5;R[11]=R[7];R[7]=R[4];R[4]=R[3];R[5]=R[8];R[3]=R[11];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1357:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=6;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1358:if(acc==1){R[4]=F(61);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(35);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[8]=G(R[2],2);R[9]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[9];R[3]=(word)fp;fp+=3;R[4]=G(R[1],2);ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1359:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(4,TPROC);fp[1]=G(R[2],5);fp[3]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=4;R[10]=F(10);R[11]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[9];R[6]=R[10];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1360:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],6);R[8]=G(R[1],5);R[9]=G(R[1],3);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=F(34);R[5]=G(R[1],6);R[6]=G(R[1],7);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[7];R[5]=(word)fp;fp+=3;R[9]=G(R[2],4);R[10]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],5);fp[2]=R[10];R[3]=(word)fp;fp+=3;R[4]=G(R[1],4);ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1361:if(acc==1){R[4]=F(34);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1362:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],6);R[7]=G(R[1],3);R[8]=G(R[1],5);R[9]=G(R[1],4);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],6);R[5]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[2],5);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[7];R[3]=(word)fp;fp+=3;R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1363:if(acc==4){if(R[5]==INULL){R[7]=F(41);R[8]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[4];R[9]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[7]=G(R[2],3);R[8]=G(R[1],2);R[9]=G(R[1],3);*fp=make_header(8,TCLOS);fp[1]=G(R[2],4);fp[7]=R[3];fp[6]=R[9];fp[5]=R[4];fp[4]=R[5];fp[3]=R[8];fp[2]=R[6];R[3]=(word)fp;fp+=8;R[6]=IFALSE;ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1364:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],7);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],2);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],5);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[10]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1365:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[3];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[5]=F(0);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1366:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],8);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[7]=F(61);R[8]=G(R[1],5);R[9]=G(R[1],2);R[10]=G(R[1],3);R[11]=G(R[1],4);R[12]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[12];fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[13]=(word)fp;fp+=7;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[13];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=1;}else{R[7]=F(41);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[10];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1367:if(acc==1){R[4]=F(35);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[7];R[3]=(word)fp;fp+=3;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1368:if(acc==1){R[4]=F(35);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(32);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(46);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1369:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[8];fp[3]=R[6];fp[2]=R[7];R[9]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1370:if(acc==2){R[5]=F(41);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[4];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1371:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=F(0);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1372:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1373:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],6);R[9]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=R[7];R[7]=R[4];R[3]=R[6];R[5]=R[8];R[6]=R[10];R[4]=R[11];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],6);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],7);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[9];fp[2]=R[4];R[10]=(word)fp;fp+=4;R[3]=R[7];R[7]=R[6];R[4]=R[8];R[6]=R[10];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1374:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1375:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);if(R[5]==INULL){R[6]=G(R[4],2);R[7]=G(R[1],4);R[4]=G(R[1],3);R[5]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}else{R[6]=G(R[4],2);R[7]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=G(R[1],3);R[5]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1376:if(acc==2){R[5]=F(41);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[8]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1377:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(46);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1378:if(acc==1){R[4]=F(40);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1379:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],5);R[5]=G(R[1],6);R[6]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=5;R[8]=G(R[1],4);if(R[8]==IFALSE){R[3]=G(R[2],4);ob=(word *)R[7];acc=1;}else{R[3]=G(R[2],5);ob=(word *)R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1380:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],7);R[8]=G(R[1],6);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],3);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1381:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],5);R[10]=G(R[1],4);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1382:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],7);R[7]=G(R[1],6);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=G(R[1],3);R[6]=IFALSE;R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1383:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=4;R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[9];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],8);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[2],7);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[6]=(word)fp;fp+=3;R[10]=G(R[2],5);R[3]=G(R[1],2);R[4]=G(R[2],2);R[13]=G(R[1],3);R[14]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],6);fp[3]=R[14];fp[2]=R[13];R[5]=(word)fp;fp+=4;ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1384:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],2);if(R[4]==R[5]){R[6]=F(121);R[7]=G(R[1],4);R[8]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=4;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[9];R[10]=(word)fp;fp+=3;R[11]=F(116);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=F(112);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[14]=(word)fp;fp+=3;R[15]=F(109);*fp=PAIRHDR;fp[1]=R[15];fp[2]=R[14];R[16]=(word)fp;fp+=3;R[17]=F(101);*fp=PAIRHDR;fp[1]=R[17];fp[2]=R[16];R[18]=(word)fp;fp+=3;R[19]=F(35);*fp=PAIRHDR;fp[1]=R[19];fp[2]=R[18];R[3]=(word)fp;fp+=3;R[21]=G(R[1],6);ob=(word *)R[21];acc=1;}else{R[6]=G(R[2],4);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],5);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=7;ob=(word *)R[6];acc=2;}}else{R[4]=G(R[2],6);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],7);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1385:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[7];R[5]=R[3];R[7]=R[4];R[3]=R[6];R[6]=R[8];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1386:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],5);fp[3]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=4;R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1387:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],2);if(R[4]==R[5]){R[6]=G(R[2],3);R[3]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[9];fp[2]=R[8];R[5]=(word)fp;fp+=4;ob=(word *)R[6];acc=3;}else{R[6]=G(R[2],5);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[4]=G(R[2],7);ob=(word *)R[6];acc=2;}}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],8);fp[3]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=4;R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1388:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=4;R[9]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1389:if(acc==1){R[4]=F(41);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(40);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(39);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1390:if(acc==4){if(R[4]==INULL){R[7]=F(41);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[5];R[8]=(word)fp;fp+=3;R[9]=F(40);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1391:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=F(10);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1392:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1393:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],5);*fp=make_header(3,TCLOS);fp[1]=G(R[2],5);fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=F(41);R[7]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[9];R[3]=(word)fp;fp+=3;R[4]=G(R[1],3);R[6]=R[5];R[5]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1394:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[8];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1395:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],6);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=G(R[1],3);R[3]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[9];fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=G(R[1],3);R[4]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1396:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(46);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[9]=G(R[1],2);ob=(word *)R[9];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1397:if(acc==1){assert(pairp(R[3]),R[3],1053);R[4]=G(R[3],2);R[5]=F(40);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1398:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],6);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);if(R[7]==IFALSE){R[3]=G(R[2],4);ob=(word *)R[6];acc=1;}else{R[3]=G(R[2],5);ob=(word *)R[6];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1399:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],5);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1400:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],2);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1401:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],5);R[5]=G(R[1],3);R[6]=G(R[2],4);R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[3]=R[5];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1402:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],6);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[9];R[10]=(word)fp;fp+=4;R[5]=G(R[1],2);R[9]=R[4];R[6]=R[3];R[3]=R[8];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1403:if(acc==3){R[6]=G(R[1],2);R[7]=prim_ref(R[6],R[5]);R[6]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[5]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1404:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1405:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=R[3];R[3]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1406:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],2);if(R[4]==R[5]){R[6]=F(121);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=F(116);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=F(112);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=F(109);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[14]=(word)fp;fp+=3;R[15]=F(101);*fp=PAIRHDR;fp[1]=R[15];fp[2]=R[14];R[16]=(word)fp;fp+=3;R[17]=F(35);*fp=PAIRHDR;fp[1]=R[17];fp[2]=R[16];R[3]=(word)fp;fp+=3;R[19]=G(R[1],5);ob=(word *)R[19];acc=1;}else{R[6]=G(R[2],3);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[6];acc=2;}}else{R[4]=G(R[2],5);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1407:if(acc==1){R[4]=F(114);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(35);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1408:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[4]=R[3];R[5]=R[7];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1409:if(acc==1){R[4]=F(35);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1410:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(116);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(101);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=F(107);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=F(99);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[13]=(word)fp;fp+=3;R[14]=F(111);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[13];R[15]=(word)fp;fp+=3;R[16]=F(115);*fp=PAIRHDR;fp[1]=R[16];fp[2]=R[15];R[17]=(word)fp;fp+=3;R[18]=F(91);*fp=PAIRHDR;fp[1]=R[18];fp[2]=R[17];R[19]=(word)fp;fp+=3;R[20]=F(35);*fp=PAIRHDR;fp[1]=R[20];fp[2]=R[19];R[3]=(word)fp;fp+=3;R[22]=G(R[1],2);ob=(word *)R[22];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1411:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1412:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(112);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(99);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=F(116);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=F(91);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[13]=(word)fp;fp+=3;R[14]=F(35);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[13];R[3]=(word)fp;fp+=3;R[16]=G(R[1],2);ob=(word *)R[16];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1413:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1414:if(acc==1){R[4]=F(93);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[8];R[9]=(word)fp;fp+=3;R[4]=R[3];R[5]=R[6];R[6]=R[7];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1415:if(acc==1){R[4]=F(32);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(100);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(102);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=F(91);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[11]=(word)fp;fp+=3;R[12]=F(35);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[3]=(word)fp;fp+=3;R[14]=G(R[1],2);ob=(word *)R[14];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1416:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],2);if(R[4]==R[5]){R[6]=F(121);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=F(116);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=F(112);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[12]=(word)fp;fp+=3;R[13]=F(109);*fp=PAIRHDR;fp[1]=R[13];fp[2]=R[12];R[14]=(word)fp;fp+=3;R[15]=F(101);*fp=PAIRHDR;fp[1]=R[15];fp[2]=R[14];R[16]=(word)fp;fp+=3;R[17]=F(35);*fp=PAIRHDR;fp[1]=R[17];fp[2]=R[16];R[3]=(word)fp;fp+=3;R[19]=G(R[1],4);ob=(word *)R[19];acc=1;}else{R[6]=G(R[2],3);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[4]=G(R[2],5);ob=(word *)R[6];acc=2;}}else{R[4]=F(102);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(111);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=F(101);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=F(35);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[3]=(word)fp;fp+=3;R[13]=G(R[1],4);ob=(word *)R[13];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1417:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1418:if(acc==1){R[4]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1419:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1420:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1421:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[3];fp[5]=R[4];fp[4]=R[5];fp[3]=R[6];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1422:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],6);R[3]=G(R[1],5);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1423:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=IFALSE;R[11]=R[4];R[5]=R[6];R[4]=R[7];R[6]=R[10];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1424:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],4);R[6]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(1);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1425:if(acc==1){R[4]=G(R[1],2);if(immediatep(R[4])){R[5]=IFALSE;}else{word h=V(R[4]);R[5]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}if(R[5]==IFALSE){R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[3];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1426:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);R[9]=R[4];R[6]=R[3];R[3]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1427:if(acc==2){R[5]=F(0);R[6]=prim_cast((word *)R[4],fixval(R[5])&63);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1428:if(acc==2){R[5]=F(62);R[6]=prim_cast((word *)R[4],fixval(R[5])&63);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1429:if(acc==2){R[5]=F(44);R[6]=prim_cast((word *)R[4],fixval(R[5])&63);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1430:if(acc==2){R[5]=F(12);R[6]=prim_cast((word *)R[4],fixval(R[5])&63);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1431:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(62);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1432:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(44);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1433:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(12);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1434:if(acc==5){if(R[6]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{{word *ob=(word *)R[6];word hdr;assert(allocp(R[6]),R[6],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];R[10]=ob[3];}*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[3];fp[3]=R[4];fp[2]=R[9];R[3]=(word)fp;fp+=5;R[6]=R[10];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1435:if(acc==5){{word ob=R[6];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(14);if(R[8]==R[9]){{word *ob=(word *)R[6];word hdr;assert(allocp(R[6]),R[6],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[10]=ob[1];R[11]=ob[2];R[12]=ob[3];}*fp=make_header(7,TCLOS);fp[1]=G(R[1],2);fp[6]=R[4];fp[5]=R[3];fp[4]=R[10];fp[3]=R[7];fp[2]=R[11];R[3]=(word)fp;fp+=7;R[6]=R[12];ob=(word *)R[7];acc=5;}else{R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1436:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[6]=G(R[1],2);R[10]=R[7];R[5]=R[3];R[7]=R[4];R[3]=R[8];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1437:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);R[4]=G(R[1],3);R[5]=R[6];ob=(word *)R[8];acc=3;}else{{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[8]=ob[1];R[9]=ob[2];R[10]=ob[3];}R[11]=G(R[1],4);*fp=make_header(9,TCLOS);fp[1]=G(R[1],5);fp[8]=R[3];fp[7]=R[8];fp[6]=R[10];fp[5]=R[9];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[4]=R[5];R[5]=R[8];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1438:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],6);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[5]=R[9];R[4]=R[12];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],6);R[6]=G(R[1],7);R[7]=G(R[1],8);*fp=make_header(5,TPROC);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],5);R[10]=G(R[1],2);R[7]=G(R[1],3);R[12]=R[4];R[5]=R[6];R[3]=R[8];R[4]=R[9];R[6]=R[10];ob=(word *)R[12];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1439:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=make_header(4,10);fp[1]=R[4];fp[2]=R[3];fp[3]=R[5];R[3]=(word)fp;fp+=4;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1440:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],3);R[6]=G(R[1],2);R[5]=R[3];R[7]=R[4];R[3]=R[8];R[4]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1441:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=make_header(4,10);fp[1]=R[4];fp[2]=R[5];fp[3]=R[3];R[3]=(word)fp;fp+=4;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1442:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=10;R[8]=R[4];R[4]=R[5];R[5]=R[3];R[3]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1443:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],3);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[5]=F(1);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(8,TCLOS);fp[1]=G(R[2],5);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],2);R[5]=F(1);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1444:if(acc==1){R[4]=G(R[1],2);R[5]=F(2);R[3]=prim_set(R[4],R[5],R[3]);R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1445:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],6);R[6]=G(R[1],7);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],4);R[9]=G(R[1],3);R[10]=G(R[1],2);R[11]=R[8];R[6]=R[3];R[8]=R[4];R[3]=R[7];R[5]=R[9];R[7]=R[10];R[4]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1446:if(acc==3){if(R[5]==INULL){R[6]=F(1);*fp=make_header(4,10);fp[1]=R[6];fp[2]=R[4];fp[3]=R[5];R[7]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[6]=ob[1];R[7]=ob[2];R[8]=ob[3];}if(R[8]==INULL){R[9]=F(1);*fp=make_header(4,10);fp[1]=R[9];fp[2]=R[4];fp[3]=R[5];R[10]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[10];acc=1;}else{{word *ob=(word *)R[8];word hdr;assert(allocp(R[8]),R[8],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=4),ob,IFALSE);R[9]=ob[1];R[10]=ob[2];R[11]=ob[3];}R[12]=G(R[1],2);*fp=make_header(10,TCLOS);fp[1]=G(R[1],3);fp[9]=R[3];fp[8]=R[11];fp[7]=R[4];fp[6]=R[7];fp[5]=R[10];fp[4]=R[5];fp[3]=R[6];fp[2]=R[9];R[3]=(word)fp;fp+=10;R[4]=R[6];R[5]=R[9];ob=(word *)R[12];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1447:if(acc==1){if(R[3]==IFALSE){R[4]=F(1);R[5]=G(R[1],7);R[6]=G(R[1],4);*fp=make_header(4,10);fp[1]=R[4];fp[2]=R[5];fp[3]=R[6];R[3]=(word)fp;fp+=4;R[8]=G(R[1],9);ob=(word *)R[8];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);R[9]=G(R[1],9);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1448:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[5]=F(1);R[8]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1449:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);*fp=make_header(4,14);fp[1]=R[4];fp[2]=R[5];fp[3]=R[6];R[7]=(word)fp;fp+=4;R[8]=G(R[1],5);*fp=make_header(4,10);fp[1]=R[3];fp[2]=R[7];fp[3]=R[8];R[3]=(word)fp;fp+=4;R[10]=G(R[1],6);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1450:if(acc==2){if(R[4]==INULL){R[5]=ITRUE;ob=(word *)R[3];R[3]=R[5];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(10);if(R[5]==R[6]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1451:if(acc==4){if(R[4]==R[5]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1452:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],5);R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1453:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1454:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1455:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);assert(pairp(R[6]),R[6],1052);R[7]=G(R[6],1);R[8]=G(R[1],5);R[9]=G(R[1],4);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[9];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[7];R[6]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1456:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=F(1);{word r=(fixval(R[4])|(1< */ + case 1457:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1458:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1459:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(17);R[7]=(R[5]==R[6])?ITRUE:IFALSE;if(R[7]==IFALSE){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(18);R[10]=(R[8]==R[9])?ITRUE:IFALSE;if(R[10]==IFALSE){R[11]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[11];acc=1;}else{R[11]=G(R[1],3);R[3]=R[10];ob=(word *)R[11];acc=1;}}else{R[8]=G(R[1],3);R[3]=R[7];ob=(word *)R[8];acc=1;}}else{R[4]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1460:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(16);R[7]=(R[6]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1461:if(acc==2){R[5]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[6]=G(R[1],2);R[7]=INULL;R[9]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1462:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=F(0);R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1463:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[11]=F(1);R[8]=R[4];R[4]=R[5];R[5]=R[11];ob=(word *)R[8];acc=3;}else{R[4]=G(R[1],5);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1464:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],2);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],6);R[10]=G(R[1],5);R[5]=R[3];R[6]=R[8];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1465:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(2);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1466:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(4);if(R[5]==R[6]){R[7]=F(1);R[4]=prim_ref(R[4],R[7]);R[9]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[5]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[7]=G(R[1],5);R[8]=G(R[1],6);R[5]=R[4];R[4]=R[8];ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1467:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=R[4];R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[4]=G(R[1],3);R[3]=G(R[2],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1468:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1469:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[8]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1470:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(4);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1471:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(19);if(R[5]==R[6]){R[7]=G(R[1],2);ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],3);R[8]=G(R[1],4);R[5]=INULL;R[6]=R[4];R[4]=R[8];ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1472:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[5]=G(R[2],4);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1473:if(acc==4){{word ob=R[5];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(32);if(R[8]==R[7]){R[9]=INULL;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[4];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1474:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[5]=G(R[2],4);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1475:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(15);if(R[7]==R[8]){R[9]=F(1);R[4]=prim_ref(R[4],R[9]);ob=(word *)R[6];acc=4;}else{R[9]=F(19);if(R[7]==R[9]){if(immediatep(R[4])){R[10]=IFALSE;}else{word h=V(R[4]);R[10]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}R[11]=G(R[1],2);R[6]=R[5];R[5]=R[10];ob=(word *)R[11];acc=4;}else{R[10]=F(11);if(R[7]==R[10]){R[11]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[12]=G(R[1],3);R[6]=R[5];R[5]=R[11];ob=(word *)R[12];acc=4;}else{ob=(word *)R[3];R[3]=R[5];acc=1;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1476:if(acc==5){R[8]=F(1);if(R[5]==R[8]){R[9]=prim_ref(R[4],R[5]);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[6];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[9]=prim_ref(R[4],R[5]);*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1477:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1478:if(acc==1){R[4]=G(R[1],4);R[5]=prim_ref(R[4],R[3]);R[6]=G(R[1],3);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[3];fp[2]=R[6];R[8]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=3;R[10]=G(R[1],2);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1479:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1480:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1481:if(acc==4){R[7]=G(R[2],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[6];fp[4]=R[4];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1482:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[8];fp[3]=R[7];fp[2]=R[6];R[9]=(word)fp;fp+=5;R[8]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1483:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[5]=G(R[2],4);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1484:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[9]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1485:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=INULL;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[3]=R[5];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1486:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=INULL;R[9]=R[4];R[10]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1487:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(19);if(R[5]==R[6]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(11);if(R[5]==R[7]){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(15);if(R[5]==R[8]){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1488:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1489:if(acc==3){if(R[4]==INULL){R[6]=G(R[1],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[6]=G(R[4],2);if(R[6]==INULL){R[7]=G(R[4],1);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);R[4]=G(R[4],2);R[9]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[1],4);fp[4]=R[3];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1490:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[8]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1491:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=F(2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1492:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],4);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1493:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[7]=INULL;R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1494:if(acc==3){R[6]=G(R[1],2);R[9]=R[5];R[5]=R[4];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1495:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[5]==INULL){R[7]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[1],5);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[5]=G(R[1],6);R[6]=INULL;ob=(word *)R[7];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1496:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[6]=INULL;ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1497:if(acc==2){if(R[4]==INULL){R[5]=INULL;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);R[10]=G(R[2],4);R[11]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1498:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[3];R[9]=(word)fp;fp+=7;R[4]=R[3];R[3]=R[9];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1499:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=F(1);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1500:if(acc==8){R[11]=G(R[1],2);if(R[7]==R[11]){R[12]=G(R[1],3);*fp=make_header(10,TCLOS);fp[1]=G(R[1],4);fp[9]=R[10];fp[8]=R[3];fp[7]=R[4];fp[6]=R[9];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=10;R[4]=R[5];R[5]=R[7];R[6]=R[8];ob=(word *)R[12];acc=4;}else{if(R[4]==INULL){if(R[5]==INULL){R[12]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[1],6);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[12];acc=2;}else{R[12]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],7);fp[5]=R[3];fp[4]=R[9];fp[3]=R[7];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[7];R[6]=R[8];ob=(word *)R[12];acc=4;}}else{R[12]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[1],9);fp[9]=R[10];fp[8]=R[3];fp[7]=R[6];fp[6]=R[9];fp[5]=R[4];fp[4]=R[7];fp[3]=R[5];fp[2]=R[8];R[3]=(word)fp;fp+=10;ob=(word *)R[12];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1501:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[5]=G(R[1],6);R[6]=G(R[1],2);R[7]=G(R[1],4);R[8]=G(R[1],7);R[9]=G(R[1],3);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TPROC);fp[1]=G(R[2],2);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);if(R[4]==IFALSE){R[5]=G(R[1],5);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[5],1);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[2],3);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);*fp=make_header(8,TPROC);fp[1]=G(R[2],4);fp[7]=R[14];fp[6]=R[13];fp[5]=R[6];fp[4]=R[9];fp[3]=R[12];fp[2]=R[11];R[3]=(word)fp;fp+=8;R[4]=G(R[1],4);R[5]=F(1);ob=(word *)R[10];acc=3;}else{R[5]=G(R[1],5);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[5],1);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[2],3);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],5);fp[8]=R[14];fp[7]=R[13];fp[6]=R[6];fp[5]=R[9];fp[4]=R[12];fp[3]=R[11];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[4]=G(R[1],4);R[5]=F(1);ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1502:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(9,TPROC);fp[1]=G(R[2],3);fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1503:if(acc==1){R[4]=G(R[1],8);R[5]=G(R[1],7);R[6]=G(R[1],6);R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[10]=G(R[1],2);R[13]=R[10];R[10]=R[4];R[4]=R[6];R[6]=R[8];R[8]=R[3];R[3]=R[5];R[5]=R[7];R[7]=R[9];R[9]=R[13];ob=(word *)R[10];acc=8;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1504:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=IFALSE;R[10]=G(R[1],2);R[13]=R[6];R[14]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[9];R[9]=R[10];R[10]=R[4];R[4]=R[13];R[3]=R[14];ob=(word *)R[10];acc=8;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1505:if(acc==1){R[4]=G(R[1],8);R[5]=G(R[1],7);R[6]=G(R[1],6);R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[10]=G(R[1],2);R[13]=R[9];R[9]=R[10];R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];R[8]=R[13];ob=(word *)R[10];acc=8;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1506:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1507:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[12]=G(R[1],3);R[13]=G(R[1],2);R[9]=R[4];R[5]=R[6];R[4]=R[12];R[6]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1508:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1509:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=INULL;R[8]=G(R[1],2);R[9]=F(0);R[10]=ITRUE;R[13]=R[6];R[14]=R[5];R[5]=R[7];R[7]=R[9];R[9]=R[3];R[6]=R[8];R[8]=R[10];R[10]=R[4];R[4]=R[13];R[3]=R[14];ob=(word *)R[10];acc=8;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1510:if(acc==7){R[10]=G(R[1],2);ob=(word *)R[10];acc=8;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1511:if(acc==4){if(R[6]==IFALSE){R[7]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1512:if(acc==2){R[5]=F(19);R[6]=IFALSE;R[7]=prim_lraw(R[4],fixval(R[5]),R[6]);ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1513:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(19);if(R[5]==R[6]){if(immediatep(R[4])){R[7]=IFALSE;}else{word h=V(R[4]);R[7]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(15);if(R[5]==R[7]){R[8]=F(2);R[9]=prim_ref(R[4],R[8]);ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[8]=F(11);if(R[5]==R[8]){R[9]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);ob=(word *)R[3];R[3]=R[9];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=INULL;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;R[12]=G(R[1],5);*fp=PAIRHDR;fp[1]=R[12];fp[2]=R[11];R[13]=(word)fp;fp+=3;R[14]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[14];fp[2]=R[13];R[15]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[15];R[5]=(word)fp;fp+=3;R[17]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[17];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1514:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[2],3);R[6]=R[4]&R[5];R[7]=G(R[2],2);R[8]=G(R[1],3);R[4]=R[3];R[5]=R[6];R[3]=R[8];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1515:if(acc==3){R[6]=G(R[5],2);R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[6];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1516:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[4];R[8]=(word)fp;fp+=4;R[4]=R[3];R[3]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1517:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(19);if(R[7]==R[8]){R[9]=G(R[1],2);R[10]=R[5]&R[9];R[11]=prim_ref(R[4],R[10]);ob=(word *)R[3];R[3]=R[11];acc=1;}else{R[9]=F(15);if(R[7]==R[9]){R[10]=F(1);R[4]=prim_ref(R[4],R[10]);ob=(word *)R[6];acc=4;}else{R[10]=F(11);if(R[7]==R[10]){R[11]=G(R[1],2);if(R[5]==R[11]){R[12]=G(R[1],3);R[13]=prim_ref(R[4],R[12]);ob=(word *)R[3];R[3]=R[13];acc=1;}else{R[12]=R[5]&R[11];R[13]=F(1);{word res=fixval(R[12])+fixval(R[13]);R[15]=BOOL(res&(1<>TPOS)&63);}R[12]=G(R[1],4);R[4]=G(R[1],5);ob=(word *)R[12];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1518:if(acc==4){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}if(R[8]==INULL){R[9]=G(R[1],5);R[10]=prim_less(R[7],R[9]);if(R[10]==IFALSE){R[11]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[5]=R[7];ob=(word *)R[11];acc=3;}else{R[11]=G(R[1],4);R[5]=R[7];ob=(word *)R[11];acc=3;}}else{*fp=make_header(4,TCLOS);fp[1]=G(R[1],6);fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=4;R[5]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1519:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(15);if(R[6]==R[7]){R[8]=G(R[1],2);R[9]=R[5]&R[8];R[10]=F(2);{word res=fixval(R[9])+fixval(R[10]);R[12]=BOOL(res&(1<>TPOS)&63);}R[9]=G(R[1],3);R[4]=G(R[1],4);ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1520:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(19);R[7]=(R[5]==R[6])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1521:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1522:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1523:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1524:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1525:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(3);if(R[5]==R[6]){R[7]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[9]=G(R[1],4);R[5]=G(R[1],5);R[6]=R[4];R[4]=R[9];ob=(word *)R[7];acc=4;}else{R[7]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],6);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[9]=G(R[1],7);R[5]=G(R[1],8);R[6]=R[4];R[4]=R[9];ob=(word *)R[7];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1526:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1527:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[2],4);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1528:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=F(3);R[6]=IFALSE;R[3]=prim_lraw(R[4],fixval(R[5]),R[6]);R[8]=G(R[1],3);ob=(word *)R[8];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1529:if(acc==1){R[4]=F(3);R[5]=IFALSE;R[3]=prim_lraw(R[3],fixval(R[4]),R[5]);R[7]=G(R[1],2);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1530:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1531:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1532:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1533:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=R[6];ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],4);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1534:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==INULL){R[5]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);assert(pairp(R[6]),R[6],1052);R[7]=G(R[6],1);R[8]=G(R[2],3);R[9]=G(R[1],4);R[10]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],4);fp[5]=R[10];fp[4]=R[9];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1535:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1536:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[8]=(word)fp;fp+=6;if(R[3]==IFALSE){R[3]=IFALSE;ob=(word *)R[8];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[9]=G(R[5],1);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[11]=G(R[2],2);R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1537:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],3);assert(pairp(R[6]),R[6],1053);R[7]=G(R[6],2);R[6]=G(R[1],5);R[3]=G(R[1],4);R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1538:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[1],4);R[3]=ITRUE;ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1539:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[8]=INULL;R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1540:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[7]=F(0);R[8]=ITRUE;R[11]=R[5];R[12]=R[6];R[6]=R[7];R[7]=R[8];R[5]=R[12];R[8]=R[12];ob=(word *)R[11];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1541:if(acc==7){if(R[4]==INULL){R[10]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[10];acc=4;}else{R[10]=G(R[1],4);if(R[6]==R[10]){R[11]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],5);fp[5]=R[9];fp[4]=R[3];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=6;R[4]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[11];acc=4;}else{R[11]=G(R[1],6);*fp=make_header(9,TCLOS);fp[1]=G(R[1],7);fp[8]=R[9];fp[7]=R[3];fp[6]=R[4];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;ob=(word *)R[11];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1542:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],2);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],6);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[11]=(word)fp;fp+=9;if(R[6]==IFALSE){R[3]=IFALSE;ob=(word *)R[11];acc=1;}else{assert(pairp(R[8]),R[8],1052);R[12]=G(R[8],1);R[13]=G(R[2],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],4);fp[3]=R[11];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=G(R[2],5);R[5]=R[12];ob=(word *)R[13];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1543:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],7);R[12]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[12];fp[7]=R[11];fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[7];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[5];ob=(word *)R[6];acc=2;}else{R[4]=G(R[2],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(6,TPROC);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[13]=R[4];R[4]=R[10];ob=(word *)R[13];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1544:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[9]=G(R[2],2);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[13];fp[7]=R[12];fp[6]=R[6];fp[5]=R[8];fp[4]=R[11];fp[3]=R[10];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[4]=G(R[1],4);R[5]=F(1);ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1545:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],4);fp[7]=R[8];fp[6]=R[7];fp[5]=R[6];fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[9]=(word)fp;fp+=8;R[10]=G(R[1],3);if(R[10]==IFALSE){R[3]=IFALSE;ob=(word *)R[9];acc=1;}else{R[11]=G(R[2],2);R[4]=G(R[1],2);R[5]=G(R[2],3);R[3]=R[9];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1546:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[6];R[13]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[9];R[9]=R[4];R[4]=R[12];R[3]=R[13];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1547:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[2],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1548:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[12]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];R[8]=R[9];R[9]=R[4];R[4]=R[3];R[3]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1549:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=INULL;R[10]=F(0);R[11]=ITRUE;R[4]=R[8];R[8]=R[5];R[5]=R[9];R[9]=R[6];R[3]=R[7];R[6]=R[10];R[7]=R[11];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1550:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[7];R[3]=(word)fp;fp+=3;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1551:if(acc==4){if(R[6]==IFALSE){R[7]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=2;}else{R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1552:if(acc==1){R[4]=F(3);R[5]=IFALSE;R[6]=prim_lraw(R[3],fixval(R[4]),R[5]);if(R[6]==IFALSE){R[7]=G(R[2],2);R[3]=G(R[1],3);R[4]=G(R[2],3);R[5]=G(R[1],2);ob=(word *)R[7];acc=3;}else{R[7]=G(R[1],3);R[3]=R[6];ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1553:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1554:if(acc==1){R[4]=F(1);if(R[3]==R[4]){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1052);R[3]=G(R[5],1);R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[9]=(word)fp;fp+=6;R[10]=F(4);R[8]=R[5];R[4]=R[3];R[3]=R[9];R[5]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1555:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=F(1);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=F(4);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1556:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=INULL;R[5]=G(R[1],2);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1557:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=INULL;R[11]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1558:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[10]=INULL;R[6]=G(R[1],2);R[12]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[12];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1559:if(acc==2){R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[12]=G(R[2],2);R[13]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[13];R[3]=(word)fp;fp+=3;R[15]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[15];R[4]=(word)fp;fp+=3;ob=(word *)R[12];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1560:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[2],4);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1561:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[2],4);R[5]=F(0);R[10]=R[4];R[6]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1562:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=G(R[2],4);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1563:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[2],4);R[5]=F(0);R[11]=R[4];R[6]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1564:if(acc==3){R[6]=F(34);if(R[4]==R[6]){*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=F(92);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[7]=G(R[1],2);ob=(word *)R[7];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1565:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1566:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(3);if(R[7]==R[8]){R[9]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}else{R[9]=F(22);if(R[7]==R[9]){R[6]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[11]=G(R[1],4);ob=(word *)R[11];acc=4;}else{R[10]=F(21);if(R[7]==R[10]){*fp=make_header(5,TCLOS);fp[1]=G(R[1],5);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[5]=(word)fp;fp+=5;R[4]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);ob=(word *)R[5];acc=3;}else{R[11]=G(R[1],6);R[12]=G(R[1],7);R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1567:if(acc==3){R[6]=F(2);if(R[4]==R[6]){R[7]=G(R[1],2);R[4]=prim_ref(R[7],R[6]);R[6]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[6];acc=4;}else{R[7]=G(R[1],2);R[8]=prim_ref(R[7],R[4]);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[4];R[5]=(word)fp;fp+=4;R[4]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1568:if(acc==5){R[8]=F(1);if(R[6]==R[8]){R[9]=prim_ref(R[4],R[6]);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[5];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[9]=prim_ref(R[4],R[6]);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[10]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1569:if(acc==1){R[4]=G(R[1],2);R[5]=F(1);{word r=(fixval(R[4])|(1< */ + case 1570:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(3);if(R[7]==R[8]){R[9]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}else{R[9]=F(22);if(R[7]==R[9]){R[10]=G(R[1],4);R[6]=F(1);ob=(word *)R[10];acc=4;}else{R[10]=F(21);if(R[7]==R[10]){*fp=make_header(5,TCLOS);fp[1]=G(R[1],5);fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[5]=(word)fp;fp+=5;R[4]=F(2);ob=(word *)R[5];acc=3;}else{R[11]=G(R[1],6);R[12]=G(R[1],7);R[5]=R[4];R[4]=R[12];ob=(word *)R[11];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1571:if(acc==3){R[6]=G(R[1],2);R[7]=(immediatep(R[6]))?IFALSE:F(hdrsize(V(R[6]))-1);if(R[4]==R[7]){R[4]=prim_ref(R[6],R[4]);R[6]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[6];acc=4;}else{R[8]=prim_ref(R[6],R[4]);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[4];R[5]=(word)fp;fp+=4;R[4]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1572:if(acc==5){R[8]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);if(R[6]==R[8]){R[9]=prim_ref(R[4],R[6]);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[5];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[9]=prim_ref(R[4],R[6]);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[10]=(word)fp;fp+=6;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1573:if(acc==1){R[4]=G(R[1],2);R[5]=F(1);{word res=fixval(R[4])+fixval(R[5]);R[7]=BOOL(res&(1< */ + case 1574:if(acc==6){if(R[6]==R[7]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[9]=prim_ref(R[4],R[6]);*fp=make_header(7,TPROC);fp[1]=G(R[1],2);fp[6]=R[8];fp[5]=R[4];fp[4]=R[5];fp[3]=R[7];fp[2]=R[6];R[10]=(word)fp;fp+=7;*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[10];R[11]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1575:if(acc==1){R[4]=G(R[1],2);R[5]=F(1);{word res=fixval(R[4])+fixval(R[5]);R[7]=BOOL(res&(1< */ + case 1576:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(3);if(R[5]==R[6]){if(immediatep(R[4])){R[7]=IFALSE;}else{word h=V(R[4]);R[7]=(rawp(h))?F((hdrsize(h)-1)*W-((h>>8)&7)):IFALSE;}ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(22);if(R[5]==R[7]){R[8]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(21);if(R[5]==R[8]){R[9]=F(1);R[10]=prim_ref(R[4],R[9]);ob=(word *)R[3];R[3]=R[10];acc=1;}else{R[9]=G(R[1],2);R[10]=G(R[1],3);R[5]=R[4];R[4]=R[10];ob=(word *)R[9];acc=3;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1577:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(3);if(R[5]==R[6]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=F(22);if(R[5]==R[7]){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=F(21);if(R[5]==R[8]){R[9]=ITRUE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1578:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[7]=IFALSE;R[9]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1579:if(acc==5){if(R[4]==INULL){R[8]=G(R[1],2);R[4]=R[5];ob=(word *)R[8];acc=2;}else{R[8]=G(R[1],3);*fp=make_header(7,TCLOS);fp[1]=G(R[1],4);fp[6]=R[7];fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=7;ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1580:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],3);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1581:if(acc==2){if(R[3]==IFALSE){R[5]=G(R[1],3);if(R[5]==IFALSE){R[6]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],5);R[3]=G(R[1],4);R[6]=R[5];R[5]=R[7];R[7]=R[8];ob=(word *)R[7];acc=5;}}else{R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[5]=R[6];R[3]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1582:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],2);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],6);R[7]=R[6]&R[5];R[8]=G(R[2],3);if(R[8]==R[7]){R[9]=G(R[4],2);R[10]=G(R[2],4);R[11]=G(R[1],4);R[12]=G(R[1],5);R[13]=G(R[1],6);R[14]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],5);fp[7]=R[14];fp[6]=R[13];fp[5]=R[9];fp[4]=R[12];fp[3]=R[5];fp[2]=R[11];R[3]=(word)fp;fp+=8;R[4]=G(R[1],3);R[5]=F(1);ob=(word *)R[10];acc=3;}else{R[9]=G(R[1],6);R[3]=IFALSE;ob=(word *)R[9];acc=2;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1583:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[11]=G(R[1],2);R[5]=F(6);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1584:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[11]=G(R[1],2);R[5]=F(63);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1585:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[3];R[3]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1586:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],4);R[5]=IFALSE;R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1587:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[5]=G(R[1],4);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1588:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1589:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=F(6);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1590:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(31);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1591:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1592:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1593:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[2],4);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],5);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],6);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=F(12);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1594:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(15);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1595:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=F(6);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1596:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1597:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[3]=(word)fp;fp+=3;R[10]=G(R[1],5);ob=(word *)R[10];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1598:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[2],3);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],5);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=F(18);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1599:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=F(7);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1600:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=G(R[2],4);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1601:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=F(12);R[10]=R[4];R[4]=R[5];R[5]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1602:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1603:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=F(6);R[8]=R[4];R[4]=R[5];R[5]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1604:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1605:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=3;R[8]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[7];R[9]=(word)fp;fp+=3;R[10]=G(R[1],5);*fp=PAIRHDR;fp[1]=R[10];fp[2]=R[9];R[3]=(word)fp;fp+=3;R[12]=G(R[1],6);ob=(word *)R[12];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1606:if(acc==1){R[4]=G(R[2],2);R[3]=R[4]|R[3];R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1607:if(acc==3){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1608:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[1],4);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=R[6];R[5]=R[7];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1609:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[2],4);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1610:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;R[8]=G(R[1],6);R[9]=G(R[1],5);R[4]=G(R[1],4);R[5]=R[3];R[6]=R[7];R[7]=R[8];R[3]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1611:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1612:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],2);R[5]=F(1);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1613:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[10]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1614:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1615:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);if(R[4]==INULL){R[5]=G(R[1],5);R[3]=G(R[1],3);ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[5];acc=1;}}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=G(R[1],3);R[4]=R[6];R[6]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1616:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1617:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==INULL){R[5]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[4]=R[5];R[5]=R[10];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1618:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[6];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1619:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);if(R[4]==INULL){R[5]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}else{R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=G(R[1],2);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1620:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1621:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);if(R[4]==INULL){R[5]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[5];acc=2;}else{R[5]=G(R[1],2);R[6]=G(R[1],5);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[4];acc=1;}}else{R[4]=G(R[1],4);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[4]=G(R[4],2);R[7]=G(R[1],5);R[3]=R[5];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1622:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=F(1);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1623:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1624:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[1],2);R[9]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1625:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1626:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[2],4);R[5]=INULL;R[9]=R[4];R[10]=R[6];R[6]=R[3];R[4]=R[7];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1627:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[2],3);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1628:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[13]=F(1);R[8]=R[4];R[5]=R[3];R[3]=R[12];R[4]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1629:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[4];R[7]=(word)fp;fp+=3;R[8]=ITRUE;R[9]=R[6];R[6]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1630:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=F(0);R[9]=R[5];R[5]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1631:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[6];R[12]=R[5];R[5]=R[3];R[6]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[11];R[3]=R[12];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1632:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=F(1);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1633:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[4];R[10]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1634:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[5]=F(1);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1635:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1636:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1637:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[10]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1638:if(acc==3){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);if(R[6]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=G(R[1],2);ob=(word *)R[7];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1639:if(acc==3){if(R[5]==INULL){R[6]=INULL;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[8]=INULL;R[9]=F(0);R[10]=R[6];R[3]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1640:if(acc==1){assert(pairp(R[3]),R[3],1053);R[4]=G(R[3],2);if(R[4]==INULL){R[3]=G(R[3],1);R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{R[5]=G(R[2],2);R[6]=G(R[1],3);R[4]=G(R[1],2);R[8]=R[5];R[5]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1641:if(acc==4){assert(pairp(R[5]),R[5],1053);R[7]=G(R[5],2);if(R[7]==INULL){R[8]=G(R[5],1);ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1642:if(acc==6){if(R[5]==INULL){if(R[6]==INULL){R[9]=INULL;ob=(word *)R[3];R[3]=R[9];acc=1;}else{R[9]=INULL;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}}else{R[9]=F(10);if(R[7]==R[9]){assert(pairp(R[5]),R[5],1053);R[10]=G(R[5],2);R[11]=G(R[5],1);R[12]=INULL;*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[12];R[13]=(word)fp;fp+=3;*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[6];R[3]=(word)fp;fp+=4;R[7]=F(1);R[5]=R[10];R[6]=R[13];ob=(word *)R[8];acc=6;}else{R[10]=F(1);{word res=fixval(R[7])+fixval(R[10]);R[12]=BOOL(res&(1< */ + case 1643:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[5];R[5]=R[7];R[7]=R[8];R[8]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[11];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1644:if(acc==4){if(R[5]==INULL){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);R[8]=G(R[5],2);if(R[8]==INULL){R[9]=INULL;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[9];R[10]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[10];acc=1;}else{assert(pairp(R[8]),R[8],1052);R[9]=G(R[8],1);R[10]=G(R[8],2);R[11]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[10];R[3]=(word)fp;fp+=6;R[5]=R[7];R[6]=R[9];ob=(word *)R[11];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1645:if(acc==5){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{if(R[6]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[6]),R[6],1052);R[8]=G(R[6],1);assert(pairp(R[5]),R[5],1052);R[9]=G(R[5],1);*fp=make_header(7,TCLOS);fp[1]=G(R[1],2);fp[6]=R[3];fp[5]=R[7];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[11]=R[4];R[4]=R[8];R[5]=R[9];ob=(word *)R[11];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1646:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=G(R[1],4);R[11]=G(R[1],2);R[5]=R[6];R[6]=R[11];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[4]=G(R[1],4);R[5]=G(R[1],3);ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1647:if(acc==5){if(R[4]==INULL){R[8]=INULL;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[9]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[9];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[8]=G(R[4],1);*fp=make_header(7,TCLOS);fp[1]=G(R[1],2);fp[6]=R[3];fp[5]=R[7];fp[4]=R[5];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1648:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[8];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=G(R[1],4);R[11]=G(R[1],3);R[4]=R[6];R[6]=R[11];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],4);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],6);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1649:if(acc==3){R[6]=G(R[1],2);R[7]=INULL;R[10]=R[7];R[7]=R[6];R[6]=R[5];R[5]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1650:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[9]=F(0);R[4]=R[5];R[5]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1651:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=F(0);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[5];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1652:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[5];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1653:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],5);R[3]=INULL;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1654:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=INULL;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[6];R[8]=(word)fp;fp+=3;R[9]=G(R[1],4);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[8];R[10]=(word)fp;fp+=3;R[11]=G(R[2],4);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[10];R[5]=(word)fp;fp+=3;R[13]=G(R[2],2);R[3]=G(R[1],5);R[4]=G(R[2],3);ob=(word *)R[13];acc=3;}else{R[4]=G(R[1],5);R[3]=INULL;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1655:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[3];fp[5]=R[4];fp[4]=R[7];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1656:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[3]=INULL;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[9]=R[4];R[5]=R[6];R[4]=R[8];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1657:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[6]=G(R[1],2);R[10]=R[7];R[7]=R[4];R[4]=R[3];R[5]=R[8];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1658:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=F(0);R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1659:if(acc==3){R[6]=G(R[1],2);R[5]=F(1);ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1660:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[6]=G(R[1],2);R[5]=R[3];R[3]=R[7];R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1661:if(acc==3){*fp=make_header(4,TCLOS);fp[1]=G(R[1],2);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1662:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[4];R[5]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1663:if(acc==5){if(R[6]==INULL){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{assert(pairp(R[6]),R[6],1052);R[8]=G(R[6],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1664:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],5);R[8]=G(R[1],4);R[4]=G(R[1],3);R[3]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1665:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1666:if(acc==5){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(42);if(R[8]==R[9]){R[10]=F(1);R[11]=prim_ref(R[4],R[10]);R[12]=F(2);R[4]=prim_ref(R[4],R[12]);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[3];fp[3]=R[11];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=5;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[10]=F((ob>>TPOS)&63);}R[11]=F(43);if(R[10]==R[11]){{word *ob=(word *)R[4];word hdr;assert(allocp(R[4]),R[4],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[12]=ob[1];R[13]=ob[2];}*fp=make_header(6,TPROC);fp[1]=G(R[1],6);fp[5]=R[7];fp[4]=R[3];fp[3]=R[12];fp[2]=R[6];R[14]=(word)fp;fp+=6;R[15]=F(1);if(R[13]==R[15]){R[16]=F(105);*fp=PAIRHDR;fp[1]=R[16];fp[2]=R[5];R[17]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[17];R[3]=(word)fp;fp+=3;ob=(word *)R[14];acc=1;}else{R[16]=G(R[1],3);if(R[13]==R[16]){R[17]=F(105);*fp=PAIRHDR;fp[1]=R[17];fp[2]=R[5];R[18]=(word)fp;fp+=3;R[19]=F(45);*fp=PAIRHDR;fp[1]=R[19];fp[2]=R[18];R[3]=(word)fp;fp+=3;ob=(word *)R[14];acc=1;}else{R[17]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],5);fp[6]=R[7];fp[5]=R[14];fp[4]=R[13];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=F(0);R[4]=R[13];ob=(word *)R[17];acc=3;}}}else{R[12]=G(R[1],4);*fp=make_header(7,TCLOS);fp[1]=G(R[1],7);fp[6]=R[3];fp[5]=R[7];fp[4]=R[5];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;R[5]=F(0);ob=(word *)R[12];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1667:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{R[4]=G(R[2],4);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],5);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=F(0);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1668:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[8]=G(R[1],2);R[5]=R[7];R[7]=R[4];R[4]=R[3];R[3]=R[6];R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1669:if(acc==1){R[4]=F(45);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1670:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[2],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],4);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],3);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1671:if(acc==1){if(R[3]==IFALSE){R[4]=F(105);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],6);R[8]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[8];R[3]=(word)fp;fp+=3;R[4]=G(R[1],4);R[11]=G(R[1],3);R[5]=R[6];R[6]=R[11];ob=(word *)R[7];acc=5;}else{R[4]=F(105);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],6);R[8]=G(R[1],5);R[4]=G(R[1],4);R[10]=G(R[1],3);R[5]=R[6];R[3]=R[8];R[6]=R[10];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1672:if(acc==1){R[4]=F(43);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1673:if(acc==1){R[4]=F(47);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[3]=R[7];R[7]=R[6];R[4]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1674:if(acc==4){R[7]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[6];R[9]=(word)fp;fp+=3;R[6]=G(R[1],5);R[5]=R[4];R[4]=R[9];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1675:if(acc==2){R[5]=G(R[2],2);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1676:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[2],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1677:if(acc==3){*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1678:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=F(10);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1679:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[4];R[6]=(word)fp;fp+=4;if(R[3]==IFALSE){R[3]=F(87);ob=(word *)R[6];acc=1;}else{R[3]=F(48);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1680:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[7]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1681:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[5]=G(R[1],2);R[10]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1682:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[11]=R[6];R[12]=R[5];R[5]=R[7];R[7]=R[3];R[6]=R[8];R[8]=R[4];R[4]=R[11];R[3]=R[12];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1683:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=F(0);R[7]=G(R[1],2);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1684:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],2);R[6]=G(R[1],3);R[7]=G(R[6],1);R[8]=G(R[2],2);R[9]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1685:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[8]=R[4];R[4]=R[6];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1686:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1687:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=F(0);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1688:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1689:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[8];fp[5]=R[4];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[6]=R[4];R[4]=R[3];R[5]=R[7];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1690:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1691:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=9;R[8]=R[4];R[4]=R[7];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1692:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1693:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],7);R[11]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],3);fp[9]=R[11];fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=10;R[8]=R[4];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1694:if(acc==1){R[4]=G(R[1],7);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);R[10]=G(R[1],8);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[10];fp[7]=R[4];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=9;R[6]=R[4];R[4]=R[3];R[5]=R[9];R[3]=R[11];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1695:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[3];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[11]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1696:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[10]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1697:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[9];fp[7]=R[4];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=9;R[9]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1698:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],2);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[9]=G(R[1],3);R[5]=G(R[1],2);R[6]=R[4];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1699:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[7]=(word)fp;fp+=5;R[8]=G(R[1],3);R[5]=G(R[1],2);R[6]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1700:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],2);R[6]=G(R[2],2);R[7]=G(R[1],3);R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1701:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[6];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1702:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,43);fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1703:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,42);fp[1]=R[3];fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[4]=R[5];R[3]=R[7];R[5]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1704:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1705:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],2);*fp=make_header(3,42);fp[1]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1706:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[8]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1707:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1708:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,43);fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1709:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[5]=G(R[1],2);R[6]=R[4];R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1710:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=R[4];R[4]=R[5];R[5]=R[6];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1711:if(acc==1){R[4]=F(1);if(R[3]==R[4]){R[5]=G(R[1],3);if(R[5]==R[4]){R[6]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(3,42);fp[1]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[8]=G(R[1],4);ob=(word *)R[8];acc=1;}}else{R[5]=G(R[2],2);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=G(R[1],4);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[3];fp[2]=R[6];R[9]=(word)fp;fp+=6;R[8]=R[5];R[4]=R[3];R[5]=R[7];R[3]=R[9];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1712:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[4]=R[9];ob=(word *)R[10];acc=3;}else{R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],2);R[7]=G(R[1],3);R[8]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1713:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1714:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1715:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,42);fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1716:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[5];R[5]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1717:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=7;R[4]=G(R[2],4);R[13]=F(0);R[9]=R[6];R[6]=R[13];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1718:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[9]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[5];R[5]=R[3];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1719:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[10]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1720:if(acc==1){if(R[3]==IFALSE){R[4]=F(2);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(1);R[8]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[8];R[5]=(word)fp;fp+=3;R[7]=G(R[1],7);R[3]=G(R[1],6);R[12]=G(R[1],5);R[4]=R[6];R[6]=R[12];ob=(word *)R[7];acc=5;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1721:if(acc==1){R[4]=F(2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=F(1);R[7]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],5);R[3]=G(R[1],4);R[6]=G(R[1],3);R[4]=R[5];R[5]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1722:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[5]=F(1);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1723:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1724:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1725:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[4]=R[3];R[3]=R[7];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1726:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1727:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[4];R[7]=(word)fp;fp+=4;R[4]=R[3];R[3]=R[7];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1728:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1729:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[6];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1730:if(acc==2){R[5]=G(R[2],2);R[3]=G(R[1],2);ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1731:if(acc==2){R[5]=G(R[1],2);R[3]=R[4];ob=(word *)R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1732:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[7]=G(R[1],2);R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1733:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1734:if(acc==4){{word ob=R[4];if(allocp(ob))ob=V(ob);R[7]=F((ob>>TPOS)&63);}R[8]=F(32);if(R[7]==R[8]){R[9]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[9];acc=2;}else{R[9]=F(41);if(R[7]==R[9]){R[10]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],4);fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[10];acc=2;}else{R[10]=G(R[1],5);ob=(word *)R[10];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1735:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[9]=R[6];R[6]=R[4];R[4]=R[3];R[5]=R[7];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1736:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1737:if(acc==2){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[5]=G(R[1],2);ob=(word *)R[5];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1738:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[9]=F(1);R[4]=R[5];R[5]=R[9];ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1739:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[5]=F(1);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1740:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TPROC);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[11];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1741:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],1);R[6]=G(R[1],5);R[7]=R[6]|R[5];R[8]=G(R[4],2);*fp=NUMHDR;fp[1]=R[7];fp[2]=R[8];R[9]=(word)fp;fp+=3;R[10]=G(R[1],7);R[11]=G(R[1],6);R[5]=G(R[1],4);R[7]=G(R[1],3);R[4]=R[6];R[6]=R[3];R[8]=R[9];R[9]=R[10];R[3]=R[11];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1742:if(acc==1){R[4]=F(0);R[5]=G(R[1],2);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=F(1);R[10]=G(R[1],3);R[12]=R[8];R[8]=R[6];R[6]=R[3];R[5]=R[4];R[4]=R[9];R[9]=R[7];R[7]=R[10];R[3]=R[12];ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1743:if(acc==6){R[9]=G(R[1],2);ob=(word *)R[9];acc=7;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1744:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TCLOS);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[5]=R[3];R[3]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1745:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TCLOS);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1746:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],2);R[6]=G(R[1],3);R[7]=G(R[6],2);R[6]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(4,TCLOS);fp[1]=G(R[2],2);fp[3]=R[9];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1747:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[5]=R[6];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1748:if(acc==3){R[6]=G(R[2],2);R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[5];fp[4]=R[3];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[9]=F(0);R[10]=R[6];R[5]=R[7];R[6]=R[9];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1749:if(acc==1){R[4]=F(2);R[5]=prim_less(R[3],R[4]);if(R[5]==IFALSE){R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[9];fp[3]=R[8];fp[2]=R[7];R[10]=(word)fp;fp+=5;R[4]=G(R[1],2);R[5]=R[3];R[3]=R[10];ob=(word *)R[6];acc=3;}else{R[6]=G(R[2],4);R[3]=G(R[1],4);R[4]=G(R[1],3);R[5]=G(R[1],2);ob=(word *)R[6];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1750:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1751:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1752:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1753:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[4];R[3]=R[5];R[5]=R[7];R[4]=R[9];ob=(word *)R[6];acc=4;}else{R[4]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1754:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1755:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1756:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],2);R[4]=R[3];R[3]=R[6];ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1757:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=F(0);R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1758:if(acc==4){R[7]=G(R[2],2);R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[6];fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[6]=F(0);R[5]=R[8];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1759:if(acc==1){R[4]=F(2);R[5]=prim_less(R[3],R[4]);if(R[5]==IFALSE){R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[10];fp[5]=R[9];fp[4]=R[8];fp[3]=R[3];fp[2]=R[7];R[11]=(word)fp;fp+=7;R[4]=G(R[1],2);R[5]=R[3];R[3]=R[11];ob=(word *)R[6];acc=3;}else{R[6]=G(R[2],4);R[7]=G(R[1],5);R[4]=G(R[1],3);R[5]=G(R[1],2);R[10]=G(R[1],4);R[11]=R[6];R[3]=R[7];R[6]=R[10];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1760:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=F(1);R[5]=G(R[1],2);R[11]=R[4];R[4]=R[9];ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1761:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1762:if(acc==5){R[8]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[5];fp[3]=R[6];fp[2]=R[4];R[3]=(word)fp;fp+=7;ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1763:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],6);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=8;R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1764:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[10]=G(R[1],3);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],6);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1765:if(acc==1){R[4]=G(R[1],2);R[5]=prim_less(R[4],R[3]);if(R[5]==IFALSE){R[6]=G(R[2],2);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=R[6];R[5]=R[3];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[6]=G(R[2],3);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=R[6];R[5]=R[3];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1766:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=G(R[2],3);R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1767:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[10]=R[5];R[5]=R[7];R[7]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1768:if(acc==1){{word *ob=(word *)R[3];word hdr;assert(allocp(R[3]),R[3],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[4]=ob[1];R[5]=ob[2];}R[6]=G(R[2],2);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=INULL;R[10]=R[6];R[3]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1769:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);R[6]=G(R[4],2);R[7]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1770:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1771:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1772:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],4);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1773:if(acc==3){R[6]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1774:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1775:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],3);R[5]=G(R[1],2);R[9]=R[4];R[3]=R[6];R[4]=R[7];ob=(word *)R[9];acc=3;}else{R[4]=G(R[1],4);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1776:if(acc==3){{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(42);if(R[6]==R[7]){{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==R[7]){R[9]=G(R[4],1);R[10]=G(R[5],2);R[11]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=5;R[4]=R[9];R[5]=R[10];ob=(word *)R[11];acc=3;}else{R[9]=G(R[4],1);R[10]=G(R[4],2);R[11]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[10];ob=(word *)R[11];acc=3;}}else{{word ob=R[5];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}if(R[8]==R[7]){R[9]=G(R[5],2);R[10]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[5]=R[9];ob=(word *)R[10];acc=3;}else{R[9]=G(R[1],6);ob=(word *)R[9];acc=3;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1777:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],1);R[6]=G(R[2],2);R[7]=G(R[1],3);R[4]=R[3];R[3]=R[7];ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1778:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],1);R[6]=G(R[1],3);R[7]=G(R[6],2);R[8]=G(R[2],2);R[9]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[9];fp[2]=R[3];R[3]=(word)fp;fp+=4;R[4]=R[5];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1779:if(acc==5){R[8]=F(30);R[9]=prim_less(R[7],R[8]);if(R[9]==IFALSE){R[10]=G(R[1],4);R[11]=G(R[1],5);*fp=make_header(9,TCLOS);fp[1]=G(R[2],2);fp[8]=R[11];fp[7]=R[7];fp[6]=R[10];fp[5]=R[5];fp[4]=R[6];fp[3]=R[3];fp[2]=R[4];R[12]=(word)fp;fp+=9;R[4]=R[3];R[6]=R[10];R[3]=R[12];ob=(word *)R[6];acc=4;}else{R[10]=G(R[2],3);R[3]=G(R[1],5);R[4]=G(R[1],3);R[5]=G(R[1],2);ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1780:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(10,TCLOS);fp[1]=G(R[2],2);fp[9]=R[10];fp[8]=R[3];fp[7]=R[9];fp[6]=R[4];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=10;R[6]=R[4];R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1781:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);R[10]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[10];fp[7]=R[9];fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=9;R[12]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1782:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[9];fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=8;R[11]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[4];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1783:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[9];R[4]=R[10];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1784:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1785:if(acc==10){if(R[4]==INULL){R[13]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[3];fp[5]=R[11];fp[4]=R[9];fp[3]=R[7];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[4]=R[6];ob=(word *)R[13];acc=2;}else{if(R[5]==INULL){R[13]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],4);fp[6]=R[3];fp[5]=R[11];fp[4]=R[9];fp[3]=R[7];fp[2]=R[8];R[3]=(word)fp;fp+=7;R[4]=R[6];ob=(word *)R[13];acc=2;}else{if(R[10]==IFALSE){{word *ob=(word *)R[6];word hdr;assert(allocp(R[6]),R[6],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[13]=ob[1];R[14]=ob[2];}{word *ob=(word *)R[7];word hdr;assert(allocp(R[7]),R[7],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[15]=ob[1];R[16]=ob[2];}R[17]=F(1);{word res=fixval(R[11])+fixval(R[17]);R[19]=BOOL(res&(1< */ + case 1786:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[3];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1787:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1788:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(7,TPROC);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=G(R[1],2);R[7]=R[4];R[4]=R[10];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1789:if(acc==1){R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1790:if(acc==9){R[12]=G(R[1],2);ob=(word *)R[12];acc=10;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1791:if(acc==2){R[5]=G(R[4],2);if(R[5]==INULL){R[6]=G(R[4],1);ob=(word *)R[3];R[3]=R[6];acc=1;}else{ob=(word *)R[3];R[3]=R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1792:if(acc==4){if(R[4]==INULL){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);R[4]=G(R[4],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],2);fp[4]=R[3];fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1793:if(acc==1){R[4]=F(0);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[5]=(word)fp;fp+=3;R[6]=G(R[2],2);R[7]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[7];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[9]=G(R[1],3);R[5]=G(R[1],2);R[11]=R[6];R[6]=R[4];R[4]=R[9];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1794:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);R[6]=G(R[1],6);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[5]=G(R[1],2);R[6]=R[3];R[3]=R[7];R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1795:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],2);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=INULL;R[8]=G(R[1],2);R[10]=R[7];R[11]=R[6];R[6]=R[3];R[7]=R[4];R[5]=R[8];R[4]=R[10];R[3]=R[11];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1796:if(acc==1){if(R[3]==INULL){R[4]=G(R[1],2);R[3]=F(0);ob=(word *)R[4];acc=1;}else{R[4]=G(R[3],2);if(R[4]==INULL){R[3]=G(R[3],1);R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{R[5]=G(R[1],2);ob=(word *)R[5];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1797:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[5]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=G(R[4],1);R[8]=G(R[5],1);R[9]=R[7]^(R[8]^2);R[4]=G(R[4],2);R[5]=G(R[5],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1798:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[5]==INULL){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[7]=G(R[4],1);R[8]=G(R[5],1);R[9]=R[7]|R[8];R[4]=G(R[4],2);R[5]=G(R[5],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1799:if(acc==4){if(R[4]==INULL){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==INULL){R[7]=F(0);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);R[8]=G(R[5],1);R[9]=R[7]&R[8];R[4]=G(R[4],2);R[5]=G(R[5],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[9];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1800:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(5,TPROC);fp[1]=G(R[2],3);fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=5;R[8]=G(R[1],2);R[5]=G(R[2],4);R[10]=R[4];R[4]=R[8];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1801:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[5]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1802:if(acc==3){if(R[4]==INULL){R[6]=F(0);ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[4],1);{uint64_t r=(uint64_t)fixval(R[6])<<(FBITS-fixval(R[5]));R[7]=F(r>>FBITS);R[8]=F(r&FMAX);}R[9]=G(R[4],2);R[10]=G(R[1],2);R[11]=ITRUE;R[6]=R[5];R[4]=R[7];R[5]=R[9];R[7]=R[11];ob=(word *)R[10];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1803:if(acc==1){R[4]=F(41);R[3]=prim_cast((word *)R[3],fixval(R[4])&63);R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1804:if(acc==1){R[4]=G(R[1],2);*fp=make_header(3,42);fp[1]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1805:if(acc==3){{word res=fixval(R[4])+fixval(R[5]);R[7]=BOOL(res&(1< */ + case 1806:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TCLOS);fp[1]=G(R[1],3);fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[7]=(word)fp;fp+=5;R[8]=IFALSE;R[9]=R[6];R[3]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1807:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=IFALSE;R[9]=ITRUE;R[10]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];R[7]=R[9];ob=(word *)R[10];acc=5;}else{R[4]=G(R[2],2);R[5]=G(R[1],4);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],2);R[8]=G(R[1],3);R[9]=IFALSE;R[10]=ITRUE;R[11]=R[4];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];R[7]=R[10];ob=(word *)R[11];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1808:if(acc==6){if(R[4]==INULL){R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}else{if(R[5]==INULL){if(R[6]==IFALSE){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[9]=G(R[1],2);R[5]=F(1);R[6]=R[7];ob=(word *)R[9];acc=4;}}else{R[9]=G(R[4],1);R[10]=G(R[5],1);{word r=(fixval(R[9])|(1< */ + case 1809:if(acc==4){R[7]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=ITRUE;R[10]=R[5];R[5]=R[4];R[4]=R[10];ob=(word *)R[7];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1810:if(acc==5){if(R[4]==INULL){if(R[5]==INULL){if(R[6]==IFALSE){R[8]=INULL;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=G(R[1],2);ob=(word *)R[3];R[3]=R[8];acc=1;}}else{if(R[6]==IFALSE){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[8]=G(R[1],3);R[4]=F(1);ob=(word *)R[8];acc=3;}}}else{if(R[5]==INULL){if(R[6]==IFALSE){ob=(word *)R[3];R[3]=R[4];acc=1;}else{R[8]=G(R[1],3);R[9]=F(1);R[5]=R[4];R[4]=R[9];ob=(word *)R[8];acc=3;}}else{R[8]=G(R[4],1);R[9]=G(R[5],1);{word res=fixval(R[8])+fixval(R[9]);R[11]=BOOL(res&(1< */ + case 1811:if(acc==4){{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}{word res=fixval(R[4])+fixval(R[7]);R[10]=BOOL(res&(1< */ + case 1812:if(acc==1){R[4]=G(R[1],2);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1813:if(acc==1){R[4]=F(0);*fp=NUMHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1814:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=F(2);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],3);R[5]=prim_ref(R[7],R[5]);R[9]=G(R[1],5);R[3]=G(R[1],4);R[4]=R[6];R[6]=R[9];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1815:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=G(R[4],2);R[6]=G(R[1],3);R[7]=G(R[6],2);R[6]=G(R[1],5);R[3]=G(R[1],4);R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1816:if(acc==5){if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{if(R[4]==INULL){R[8]=ITRUE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{if(R[5]==INULL){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{R[8]=G(R[4],1);R[9]=G(R[5],1);R[10]=prim_less(R[8],R[9]);if(R[10]==IFALSE){if(R[8]==R[9]){R[4]=G(R[4],2);R[5]=G(R[5],2);ob=(word *)R[7];acc=5;}else{R[4]=G(R[4],2);R[5]=G(R[5],2);R[6]=IFALSE;ob=(word *)R[7];acc=5;}}else{R[4]=G(R[4],2);R[5]=G(R[5],2);R[6]=ITRUE;ob=(word *)R[7];acc=5;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1817:if(acc==4){if(R[4]==R[5]){R[7]=ITRUE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[4]==INULL){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{if(R[5]==INULL){R[7]=IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);R[8]=G(R[5],1);if(R[7]==R[8]){R[4]=G(R[4],2);R[5]=G(R[5],2);ob=(word *)R[6];acc=4;}else{R[9]=IFALSE;ob=(word *)R[3];R[3]=R[9];acc=1;}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1818:if(acc==4){R[7]=INULL;*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[8];R[9]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[9];R[5]=(word)fp;fp+=3;R[11]=G(R[1],2);R[4]=G(R[1],3);ob=(word *)R[11];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1819:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[7]=G(R[4],2);R[8]=G(R[4],1);*fp=NUMHDR;fp[1]=R[8];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[4]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1820:if(acc==2){R[5]=F(0);R[6]=(R[4]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1821:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[10]=R[5];R[5]=R[3];R[4]=R[6];R[6]=R[7];R[3]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1822:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1823:if(acc==5){if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[6];acc=1;}else{if(R[5]==INULL){R[8]=G(R[1],2);R[5]=IFALSE;ob=(word *)R[8];acc=4;}else{R[8]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[6]=G(R[1],4);R[5]=R[8];ob=(word *)R[9];acc=4;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1824:if(acc==1){R[4]=G(R[1],2);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[4]=R[3];R[3]=R[7];R[7]=R[6];R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1825:if(acc==4){*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[4];R[7]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1826:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1827:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[6];R[6]=R[3];R[3]=R[5];R[5]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1828:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[1],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1829:if(acc==4){R[7]=G(R[1],4);R[8]=(R[4]==R[7])?ITRUE:IFALSE;R[9]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[4]=R[8];ob=(word *)R[9];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1830:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],4);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],4);assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[6]=ob[1];R[7]=ob[2];switch(hdrsize(hdr)){case 3:R[5]=IEMPTY;R[8]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1831:if(acc==1){R[4]=G(R[1],3);if(R[3]==R[4]){R[5]=G(R[1],7);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(2);R[7]=R[5]&R[6];R[8]=(R[6]==R[7])?ITRUE:IFALSE;if(R[8]==IFALSE){R[9]=G(R[2],2);R[10]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],5);R[7]=G(R[1],4);R[4]=R[3];R[3]=R[10];ob=(word *)R[9];acc=5;}else{R[9]=G(R[1],6);R[10]=G(R[1],5);R[11]=G(R[1],4);R[3]=prim_mkff(TFF|FFRED,R[3],R[9],R[10],R[11]);R[13]=G(R[1],7);ob=(word *)R[13];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1832:if(acc==1){R[4]=G(R[1],3);if(R[3]==R[4]){R[5]=G(R[1],7);R[3]=G(R[1],2);ob=(word *)R[5];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(2);R[7]=R[5]&R[6];R[8]=(R[6]==R[7])?ITRUE:IFALSE;if(R[8]==IFALSE){R[9]=G(R[2],2);R[10]=G(R[1],7);R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=R[3];R[3]=R[10];ob=(word *)R[9];acc=5;}else{R[9]=G(R[1],6);R[10]=G(R[1],5);R[11]=G(R[1],4);R[3]=prim_mkff(TFF|FFRED,R[9],R[10],R[11],R[3]);R[13]=G(R[1],7);ob=(word *)R[13];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1833:if(acc==4){R[7]=G(R[1],2);if(R[4]==R[7]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[5]==R[7]){ob=(word *)R[3];R[3]=R[4];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(2);R[10]=R[8]&R[9];R[11]=(R[9]==R[10])?ITRUE:IFALSE;if(R[11]==IFALSE){{word ob=R[5];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]&R[9];R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){R[15]=G(R[1],3);*fp=make_header(6,TCLOS);fp[1]=G(R[1],4);fp[5]=R[3];fp[4]=R[5];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;ob=(word *)R[15];acc=2;}else{assert(allocp(R[5]),R[5],1049);{word *ob=(word *)R[5];word hdr=*ob;R[16]=ob[1];R[17]=ob[2];switch(hdrsize(hdr)){case 3:R[15]=IEMPTY;R[18]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[13]=R[12]&R[9];R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[16]=ob[1];R[17]=ob[2];switch(hdrsize(hdr)){case 3:R[15]=IEMPTY;R[18]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1834:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[8];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1835:if(acc==1){{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}R[5]=F(2);R[6]=R[4]&R[5];R[7]=(R[5]==R[6])?ITRUE:IFALSE;if(R[7]==IFALSE){R[8]=G(R[1],2);assert(allocp(R[8]),R[8],1049);{word *ob=(word *)R[8];word hdr=*ob;R[10]=ob[1];R[11]=ob[2];switch(hdrsize(hdr)){case 3:R[9]=IEMPTY;R[12]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1836:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[8]=G(R[1],5);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[8];fp[5]=R[7];fp[4]=R[6];fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=7;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1837:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(5,TCLOS);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[8];R[4]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1838:if(acc==1){{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}R[5]=F(2);R[6]=R[4]&R[5];R[7]=(R[5]==R[6])?ITRUE:IFALSE;if(R[7]==IFALSE){R[8]=G(R[1],2);assert(allocp(R[8]),R[8],1049);{word *ob=(word *)R[8];word hdr=*ob;R[10]=ob[1];R[11]=ob[2];switch(hdrsize(hdr)){case 3:R[9]=IEMPTY;R[12]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1839:if(acc==2){assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[6]=ob[1];R[7]=ob[2];switch(hdrsize(hdr)){case 3:R[5]=IEMPTY;R[8]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1840:if(acc==2){assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[6]=ob[1];R[7]=ob[2];switch(hdrsize(hdr)){case 3:R[5]=IEMPTY;R[8]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1841:if(acc==5){{word ob=R[7];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(2);R[10]=R[8]&R[9];R[11]=(R[9]==R[10])?ITRUE:IFALSE;if(R[11]==IFALSE){{word ob=R[4];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]&R[9];R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){{word ob=R[4];if(allocp(ob))ob=V(ob);R[15]=F((ob>>TPOS)&63);}R[16]=R[15]^(R[9]^2);R[4]=prim_cast((word *)R[4],fixval(R[16])&63);R[18]=G(R[1],2);ob=(word *)R[18];acc=5;}else{assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[16]=ob[1];R[17]=ob[2];switch(hdrsize(hdr)){case 3:R[15]=IEMPTY;R[18]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[24]=R[23]^(R[9]^2);R[4]=prim_cast((word *)R[15],fixval(R[24])&63);R[26]=G(R[1],2);*fp=make_header(9,TPROC);fp[1]=G(R[1],3);fp[8]=R[3];fp[7]=R[20];fp[6]=R[21];fp[5]=R[22];fp[4]=R[5];fp[3]=R[6];fp[2]=R[7];R[3]=(word)fp;fp+=9;R[5]=R[16];R[6]=R[17];R[7]=R[19];ob=(word *)R[26];acc=5;}}else{{word ob=R[7];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]^(R[9]^2);R[14]=prim_cast((word *)R[7],fixval(R[13])&63);R[15]=prim_mkff(TFF|FFRED,R[4],R[5],R[6],R[14]);ob=(word *)R[3];R[3]=R[15];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1842:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[8]=prim_mkff(TFF,R[4],R[5],R[6],R[7]);R[9]=G(R[1],7);R[10]=G(R[1],6);R[3]=prim_mkff(TFF|FFRED,R[3],R[9],R[10],R[8]);R[12]=G(R[1],8);ob=(word *)R[12];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1843:if(acc==5){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(2);R[10]=R[8]&R[9];R[11]=(R[9]==R[10])?ITRUE:IFALSE;if(R[11]==IFALSE){{word ob=R[7];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]&R[9];R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){{word ob=R[7];if(allocp(ob))ob=V(ob);R[15]=F((ob>>TPOS)&63);}R[16]=R[15]^(R[9]^2);R[7]=prim_cast((word *)R[7],fixval(R[16])&63);R[18]=G(R[1],2);ob=(word *)R[18];acc=5;}else{assert(allocp(R[7]),R[7],1049);{word *ob=(word *)R[7];word hdr=*ob;R[16]=ob[1];R[17]=ob[2];switch(hdrsize(hdr)){case 3:R[15]=IEMPTY;R[18]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[25]=R[24]^(R[9]^2);R[7]=prim_cast((word *)R[18],fixval(R[25])&63);R[27]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[1],3);fp[5]=R[3];fp[4]=R[23];fp[3]=R[20];fp[2]=R[21];R[3]=(word)fp;fp+=6;R[5]=R[16];R[6]=R[17];R[4]=R[22];ob=(word *)R[27];acc=5;}}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]^(R[9]^2);R[14]=prim_cast((word *)R[4],fixval(R[13])&63);R[15]=prim_mkff(TFF|FFRED,R[14],R[5],R[6],R[7]);ob=(word *)R[3];R[3]=R[15];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1844:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=INULL;R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1845:if(acc==4){*fp=PAIRHDR;fp[1]=R[5];fp[2]=R[6];R[7]=(word)fp;fp+=3;*fp=PAIRHDR;fp[1]=R[7];fp[2]=R[4];R[8]=(word)fp;fp+=3;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1846:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[7]=G(R[1],4);R[9]=R[5];R[10]=R[6];R[6]=R[4];R[5]=R[7];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1847:if(acc==3){assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);R[7]=G(R[5],2);R[8]=G(R[1],2);R[5]=R[6];R[6]=R[7];ob=(word *)R[8];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1848:if(acc==5){R[8]=G(R[1],4);R[9]=(R[6]==R[8])?ITRUE:IFALSE;R[10]=G(R[1],2);*fp=make_header(7,TCLOS);fp[1]=G(R[1],3);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=7;R[4]=R[9];ob=(word *)R[10];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1849:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],5);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[6]=ob[1];R[7]=ob[2];switch(hdrsize(hdr)){case 3:R[5]=IEMPTY;R[8]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1850:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[2],4);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);R[8]=G(R[1],4);R[9]=G(R[1],5);R[10]=G(R[1],3);R[11]=G(R[1],7);R[12]=G(R[1],8);R[13]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[13];fp[7]=R[12];fp[6]=R[11];fp[5]=R[4];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=9;R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],6);R[5]=G(R[2],4);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);R[8]=G(R[1],2);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],5);fp[9]=R[14];fp[8]=R[13];fp[7]=R[12];fp[6]=R[4];fp[5]=R[11];fp[4]=R[10];fp[3]=R[9];fp[2]=R[8];R[3]=(word)fp;fp+=10;R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1851:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],9);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],8);R[8]=G(R[1],7);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],9);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[4];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1852:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],6);R[5]=G(R[1],7);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],6);R[5]=G(R[1],5);R[6]=G(R[1],7);R[7]=G(R[1],8);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1853:if(acc==5){R[8]=G(R[1],2);if(R[6]==R[8]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(allocp(R[6]),R[6],1049);{word *ob=(word *)R[6];word hdr=*ob;R[10]=ob[1];R[11]=ob[2];switch(hdrsize(hdr)){case 3:R[9]=IEMPTY;R[12]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1854:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[5]=G(R[2],4);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);R[8]=G(R[1],9);R[9]=G(R[1],3);R[10]=G(R[1],4);R[11]=G(R[1],5);R[12]=G(R[1],8);R[13]=G(R[1],7);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[13];fp[7]=R[12];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=9;R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],2);R[5]=G(R[2],4);R[6]=(R[4]==R[5])?ITRUE:IFALSE;R[7]=G(R[2],2);R[8]=G(R[1],3);R[9]=G(R[1],4);R[10]=G(R[1],5);R[11]=G(R[1],6);R[12]=G(R[1],7);R[13]=G(R[1],8);R[14]=G(R[1],9);*fp=make_header(10,TCLOS);fp[1]=G(R[2],5);fp[9]=R[14];fp[8]=R[13];fp[7]=R[12];fp[6]=R[11];fp[5]=R[10];fp[4]=R[9];fp[3]=R[8];fp[2]=R[4];R[3]=(word)fp;fp+=10;R[4]=R[6];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1855:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],7);R[5]=G(R[1],6);R[6]=G(R[1],8);R[7]=G(R[1],9);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],3);R[5]=G(R[1],5);R[6]=G(R[1],4);R[12]=R[4];R[4]=R[9];ob=(word *)R[12];acc=4;}else{R[4]=G(R[1],9);R[5]=G(R[1],4);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],7);R[9]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[4];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=8;R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1856:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],6);R[7]=G(R[1],7);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[8]=(word)fp;fp+=6;R[5]=G(R[1],3);R[6]=G(R[1],2);R[11]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[11];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1857:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[10]=R[6];R[11]=R[5];R[5]=R[3];R[6]=R[7];R[7]=R[4];R[4]=R[10];R[3]=R[11];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1858:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],8);R[5]=G(R[1],7);R[6]=G(R[1],4);R[7]=G(R[1],6);R[8]=G(R[1],5);R[9]=R[4];R[3]=R[5];R[4]=R[6];R[5]=R[7];R[6]=R[8];ob=(word *)R[9];acc=4;}else{R[4]=G(R[1],3);R[5]=G(R[1],5);R[6]=G(R[1],6);R[7]=G(R[1],7);R[8]=G(R[1],8);*fp=make_header(6,TPROC);fp[1]=G(R[2],2);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=G(R[1],4);R[6]=G(R[1],2);R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1859:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[9]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1860:if(acc==4){*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[3];fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[8]=G(R[1],3);R[9]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1861:if(acc==1){R[4]=G(R[2],2);if(R[3]==R[4]){R[5]=G(R[2],3);R[6]=G(R[1],5);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[6];R[7]=(word)fp;fp+=3;R[4]=G(R[1],4);R[9]=G(R[1],3);R[6]=G(R[1],2);R[11]=R[5];R[3]=R[7];R[5]=R[9];ob=(word *)R[11];acc=4;}else{R[5]=G(R[2],5);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[9]=G(R[1],2);R[10]=R[5];R[3]=R[6];R[4]=R[7];R[5]=R[8];R[6]=R[9];ob=(word *)R[10];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1862:if(acc==1){{word ob=R[3];if(allocp(ob))ob=V(ob);R[4]=F((ob>>TPOS)&63);}R[5]=F(2);R[6]=R[4]&R[5];R[7]=(R[5]==R[6])?ITRUE:IFALSE;if(R[7]==IFALSE){R[8]=G(R[1],2);ob=(word *)R[8];acc=1;}else{{word ob=R[3];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=R[8]^(R[5]^2);R[3]=prim_cast((word *)R[3],fixval(R[9])&63);R[11]=G(R[1],2);ob=(word *)R[11];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1863:if(acc==5){R[8]=G(R[1],2);if(R[4]==R[8]){R[9]=G(R[1],3);R[4]=G(R[1],4);ob=(word *)R[9];acc=3;}else{R[9]=F(1);R[10]=prim_ref(R[4],R[9]);if(R[5]==R[10]){R[11]=F(2);R[12]=prim_set(R[4],R[11],R[6]);ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[11]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[12]=F(2);if(R[11]==R[12]){R[4]=R[8];ob=(word *)R[7];acc=5;}else{R[13]=F(3);if(R[11]==R[13]){R[14]=prim_ref(R[4],R[13]);*fp=make_header(4,TPROC);fp[1]=G(R[1],5);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[14];ob=(word *)R[7];acc=5;}else{R[14]=prim_less(R[5],R[10]);if(R[14]==IFALSE){R[15]=F(4);R[16]=prim_ref(R[4],R[15]);*fp=make_header(4,TPROC);fp[1]=G(R[1],6);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[16];ob=(word *)R[7];acc=5;}else{R[15]=prim_ref(R[4],R[13]);*fp=make_header(4,TPROC);fp[1]=G(R[1],7);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[15];ob=(word *)R[7];acc=5;}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1864:if(acc==1){R[4]=G(R[1],2);R[5]=F(4);R[3]=prim_set(R[4],R[5],R[3]);R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1865:if(acc==1){R[4]=G(R[1],2);R[5]=F(3);R[3]=prim_set(R[4],R[5],R[3]);R[7]=G(R[1],3);ob=(word *)R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1866:if(acc==5){R[8]=G(R[1],2);if(R[4]==R[8]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[9]=F(1);R[10]=prim_ref(R[4],R[9]);if(R[10]==R[5]){R[11]=F(2);R[12]=prim_ref(R[4],R[11]);ob=(word *)R[3];R[3]=R[12];acc=1;}else{R[11]=prim_less(R[5],R[10]);if(R[11]==IFALSE){R[12]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[13]=F(4);if(R[12]==R[13]){R[4]=prim_ref(R[4],R[13]);ob=(word *)R[7];acc=5;}else{R[14]=F(2);if(R[12]==R[14]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[15]=F((ob>>TPOS)&63);}R[16]=R[15]&R[9];R[17]=(R[9]==R[16])?ITRUE:IFALSE;if(R[17]==IFALSE){ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[18]=F(3);R[4]=prim_ref(R[4],R[18]);ob=(word *)R[7];acc=5;}}}}else{R[12]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[13]=F(4);if(R[12]==R[13]){R[14]=F(3);R[4]=prim_ref(R[4],R[14]);ob=(word *)R[7];acc=5;}else{R[14]=F(2);if(R[12]==R[14]){ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[15]=F((ob>>TPOS)&63);}R[16]=R[15]&R[9];R[17]=(R[9]==R[16])?ITRUE:IFALSE;if(R[17]==IFALSE){R[18]=F(3);R[4]=prim_ref(R[4],R[18]);ob=(word *)R[7];acc=5;}else{ob=(word *)R[3];R[3]=R[6];acc=1;}}}}}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1867:if(acc==5){R[8]=G(R[1],2);if(R[4]==R[8]){R[9]=prim_mkff(TFF|FFRED,R[8],R[5],R[6],R[8]);ob=(word *)R[3];R[3]=R[9];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[9]=F((ob>>TPOS)&63);}R[10]=F(2);R[11]=R[9]&R[10];R[12]=(R[10]==R[11])?ITRUE:IFALSE;if(R[12]==IFALSE){assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[14]=ob[1];R[15]=ob[2];switch(hdrsize(hdr)){case 3:R[13]=IEMPTY;R[16]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1868:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[3]=prim_mkff(TFF|FFRED,R[3],R[4],R[5],R[6]);R[8]=G(R[1],5);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1869:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[3]=prim_mkff(TFF|FFRED,R[4],R[5],R[6],R[3]);R[8]=G(R[1],5);ob=(word *)R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1870:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[8];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1871:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],5);R[6]=G(R[1],4);R[7]=G(R[1],3);R[8]=G(R[1],2);R[10]=R[4];R[11]=R[5];R[5]=R[7];R[7]=R[3];R[4]=R[6];R[6]=R[8];R[3]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1872:if(acc==5){{word ob=R[7];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(2);R[10]=R[8]&R[9];R[11]=(R[9]==R[10])?ITRUE:IFALSE;if(R[11]==IFALSE){R[12]=prim_mkff(TFF,R[4],R[5],R[6],R[7]);ob=(word *)R[3];R[3]=R[12];acc=1;}else{assert(allocp(R[7]),R[7],1049);{word *ob=(word *)R[7];word hdr=*ob;R[13]=ob[1];R[14]=ob[2];switch(hdrsize(hdr)){case 3:R[12]=IEMPTY;R[15]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[17]=R[16]&R[9];R[18]=(R[9]==R[17])?ITRUE:IFALSE;if(R[18]==IFALSE){{word ob=R[15];if(allocp(ob))ob=V(ob);R[19]=F((ob>>TPOS)&63);}R[20]=R[19]&R[9];R[21]=(R[9]==R[20])?ITRUE:IFALSE;if(R[21]==IFALSE){R[22]=prim_mkff(TFF,R[4],R[5],R[6],R[7]);ob=(word *)R[3];R[3]=R[22];acc=1;}else{assert(allocp(R[15]),R[15],1049);{word *ob=(word *)R[15];word hdr=*ob;R[23]=ob[1];R[24]=ob[2];switch(hdrsize(hdr)){case 3:R[22]=IEMPTY;R[25]=IEMPTY;break;case 4:if(hdr&(1< */ + case 1873:if(acc==5){{word ob=R[4];if(allocp(ob))ob=V(ob);R[8]=F((ob>>TPOS)&63);}R[9]=F(2);R[10]=R[8]&R[9];R[11]=(R[9]==R[10])?ITRUE:IFALSE;if(R[11]==IFALSE){R[12]=prim_mkff(TFF,R[4],R[5],R[6],R[7]);ob=(word *)R[3];R[3]=R[12];acc=1;}else{{word ob=R[7];if(allocp(ob))ob=V(ob);R[12]=F((ob>>TPOS)&63);}R[13]=R[12]&R[9];R[14]=(R[9]==R[13])?ITRUE:IFALSE;if(R[14]==IFALSE){assert(allocp(R[4]),R[4],1049);{word *ob=(word *)R[4];word hdr=*ob;R[16]=ob[1];R[17]=ob[2];switch(hdrsize(hdr)){case 3:R[15]=IEMPTY;R[18]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[20]=R[19]&R[9];R[21]=(R[9]==R[20])?ITRUE:IFALSE;if(R[21]==IFALSE){{word ob=R[18];if(allocp(ob))ob=V(ob);R[22]=F((ob>>TPOS)&63);}R[23]=R[22]&R[9];R[24]=(R[9]==R[23])?ITRUE:IFALSE;if(R[24]==IFALSE){R[25]=prim_mkff(TFF,R[4],R[5],R[6],R[7]);ob=(word *)R[3];R[3]=R[25];acc=1;}else{assert(allocp(R[18]),R[18],1049);{word *ob=(word *)R[18];word hdr=*ob;R[26]=ob[1];R[27]=ob[2];switch(hdrsize(hdr)){case 3:R[25]=IEMPTY;R[28]=IEMPTY;break;case 4:if(hdr&(1<>TPOS)&63);}R[16]=R[15]^(R[9]^2);R[17]=prim_cast((word *)R[4],fixval(R[16])&63);{word ob=R[7];if(allocp(ob))ob=V(ob);R[18]=F((ob>>TPOS)&63);}R[19]=R[18]^(R[9]^2);R[20]=prim_cast((word *)R[7],fixval(R[19])&63);R[21]=prim_mkff(TFF|FFRED,R[17],R[5],R[6],R[20]);ob=(word *)R[3];R[3]=R[21];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1874:if(acc==2){R[5]=G(R[1],2);if(R[4]==R[5]){R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{word ob=R[4];if(allocp(ob))ob=V(ob);R[6]=F((ob>>TPOS)&63);}R[7]=F(124);R[8]=R[6]&R[7];R[9]=F(24);R[10]=(R[9]==R[8])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[10];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1875:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1876:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=ITRUE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1877:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1878:if(acc==2){R[5]=G(R[1],2);R[6]=(R[4]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1879:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[7]=R[5];R[5]=R[4];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1880:if(acc==5){if(R[5]==INULL){R[8]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{assert(pairp(R[5]),R[5],1053);R[8]=G(R[5],2);if(R[8]==INULL){assert(pairp(R[4]),R[4],1052);R[9]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[9];fp[2]=R[6];R[10]=(word)fp;fp+=3;R[11]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],4);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[10];ob=(word *)R[11];acc=2;}else{assert(pairp(R[4]),R[4],1053);R[9]=G(R[4],2);assert(pairp(R[8]),R[8],1053);R[5]=G(R[8],2);R[11]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[11];fp[2]=R[6];R[6]=(word)fp;fp+=3;R[4]=R[9];ob=(word *)R[7];acc=5;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1881:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],3);R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1882:if(acc==4){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[4];R[7]=(word)fp;fp+=3;R[8]=INULL;R[4]=R[5];R[5]=R[6];R[6]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1883:if(acc==5){if(R[5]==INULL){R[8]=G(R[2],2);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=4;R[4]=R[6];ob=(word *)R[8];acc=2;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);R[9]=G(R[1],2);*fp=make_header(6,TPROC);fp[1]=G(R[2],4);fp[5]=R[7];fp[4]=R[3];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[5]=R[8];ob=(word *)R[9];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1884:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=G(R[1],5);R[10]=G(R[1],4);R[4]=R[3];R[5]=R[6];R[6]=R[8];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1885:if(acc==5){if(R[5]==INULL){ob=(word *)R[3];R[3]=R[6];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);*fp=make_header(7,TPROC);fp[1]=G(R[1],2);fp[6]=R[3];fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1886:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],6);R[8]=G(R[1],4);R[9]=G(R[1],3);R[3]=R[7];R[7]=R[6];R[4]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1052);R[3]=G(R[4],1);R[6]=G(R[1],6);ob=(word *)R[6];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1887:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[5];R[4]=(word)fp;fp+=4;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1888:if(acc==2){R[5]=G(R[2],2);R[6]=G(R[1],3);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[4];fp[2]=R[6];R[7]=(word)fp;fp+=4;R[8]=ITRUE;R[6]=G(R[1],2);R[10]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[10];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1889:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[7];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1890:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=IFALSE;R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1891:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[4]=R[3];R[3]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1892:if(acc==3){R[6]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[4];R[7]=(word)fp;fp+=3;R[8]=INULL;R[9]=R[6];R[6]=R[5];R[4]=R[7];R[5]=R[8];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1893:if(acc==3){R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[2],2);fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1894:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[3]=G(R[1],3);ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);R[5]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],4);ob=(word *)R[7];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1895:if(acc==3){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[4];R[6]=(word)fp;fp+=3;R[7]=INULL;R[4]=R[5];R[5]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1896:if(acc==4){if(R[4]==INULL){R[7]=G(R[2],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[3];R[3]=(word)fp;fp+=3;R[4]=R[5];ob=(word *)R[7];acc=2;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[8]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],4);fp[5]=R[6];fp[4]=R[3];fp[3]=R[5];fp[2]=R[4];R[3]=(word)fp;fp+=6;R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1897:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);*fp=make_header(4,TPROC);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],3);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[4],1);R[7]=G(R[1],3);*fp=PAIRHDR;fp[1]=R[6];fp[2]=R[7];R[8]=(word)fp;fp+=3;R[6]=G(R[1],5);R[3]=G(R[1],4);R[4]=R[5];R[5]=R[8];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1898:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1899:if(acc==1){R[4]=G(R[1],2);R[5]=INULL;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1900:if(acc==2){R[5]=G(R[1],2);R[6]=INULL;R[8]=R[5];R[5]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1901:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1053);R[7]=G(R[4],2);R[8]=G(R[4],1);*fp=PAIRHDR;fp[1]=R[8];fp[2]=R[5];R[5]=(word)fp;fp+=3;R[4]=R[7];ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1902:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[5]=R[3];R[6]=R[4];R[3]=R[7];R[4]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1903:if(acc==3){assert(pairp(R[4]),R[4],1053);R[6]=G(R[4],2);if(R[6]==INULL){R[7]=G(R[4],1);ob=(word *)R[3];R[3]=R[7];acc=1;}else{R[7]=G(R[4],1);R[4]=G(R[4],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1904:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[6];R[10]=R[5];R[5]=R[3];R[6]=R[4];R[4]=R[9];R[3]=R[10];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1905:if(acc==5){if(R[5]==INULL){R[8]=IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[8]=G(R[5],1);*fp=make_header(7,TPROC);fp[1]=G(R[1],2);fp[6]=R[7];fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[10]=R[4];R[5]=R[6];R[4]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1906:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],6);R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[3]=R[7];R[7]=R[6];R[4]=R[8];R[6]=R[9];ob=(word *)R[7];acc=5;}else{R[4]=G(R[1],5);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1907:if(acc==3){R[6]=G(R[1],2);R[7]=G(R[1],3);R[9]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1908:if(acc==3){ob=(word *)R[3];R[3]=R[5];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1909:if(acc==4){if(R[5]==INULL){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{assert(pairp(R[5]),R[5],1052);R[7]=G(R[5],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[6];fp[4]=R[3];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=R[4];R[4]=R[7];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1910:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[4]=G(R[1],3);R[3]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1911:if(acc==4){if(R[5]==INULL){R[7]=INULL;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{word *ob=(word *)R[5];word hdr;assert(allocp(R[5]),R[5],IFALSE);hdr=*ob;assert_not((rawp(hdr)||hdrsize(hdr)!=3),ob,IFALSE);R[7]=ob[1];R[8]=ob[2];}*fp=make_header(6,TCLOS);fp[1]=G(R[1],2);fp[5]=R[3];fp[4]=R[6];fp[3]=R[4];fp[2]=R[8];R[3]=(word)fp;fp+=6;R[8]=R[4];R[4]=R[7];ob=(word *)R[8];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1912:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[5];fp[2]=R[3];R[6]=(word)fp;fp+=4;R[7]=G(R[1],3);R[5]=G(R[1],2);R[3]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1913:if(acc==5){if(R[6]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[6]),R[6],1052);R[8]=G(R[6],1);R[6]=G(R[6],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],2);fp[4]=R[4];fp[3]=R[3];fp[2]=R[8];R[3]=(word)fp;fp+=5;ob=(word *)R[7];acc=5;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1914:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1915:if(acc==6){if(R[7]==INULL){R[7]=R[3];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{assert(pairp(R[7]),R[7],1052);R[9]=G(R[7],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[8];fp[4]=R[3];fp[3]=R[4];fp[2]=R[7];R[3]=(word)fp;fp+=6;R[11]=R[4];R[4]=R[5];R[5]=R[6];R[6]=R[9];ob=(word *)R[11];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1916:if(acc==2){R[5]=G(R[1],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);R[7]=G(R[1],5);R[8]=G(R[1],4);R[9]=G(R[1],3);R[5]=R[3];R[3]=R[8];R[8]=R[7];R[7]=R[6];R[6]=R[4];R[4]=R[9];ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1917:if(acc==5){R[8]=G(R[1],2);ob=(word *)R[8];acc=6;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1918:if(acc==5){*fp=make_header(7,TCLOS);fp[1]=G(R[1],2);fp[6]=R[3];fp[5]=R[7];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=7;R[4]=R[5];ob=(word *)R[6];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1919:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],5);R[7]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[7];fp[4]=R[6];fp[3]=R[4];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{R[4]=G(R[1],6);R[3]=INULL;ob=(word *)R[4];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1920:if(acc==2){R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[3];R[7]=(word)fp;fp+=4;R[8]=G(R[1],3);R[6]=G(R[1],2);R[3]=R[7];R[7]=R[5];R[5]=R[4];R[4]=R[8];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1921:if(acc==5){if(R[6]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[6]),R[6],1052);R[8]=G(R[6],1);*fp=make_header(6,TPROC);fp[1]=G(R[1],2);fp[5]=R[7];fp[4]=R[3];fp[3]=R[4];fp[2]=R[6];R[3]=(word)fp;fp+=6;R[10]=R[4];R[4]=R[5];R[5]=R[8];ob=(word *)R[10];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1922:if(acc==1){R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],5);R[7]=G(R[1],4);R[8]=G(R[1],3);R[10]=R[7];R[7]=R[6];R[6]=R[5];R[5]=R[3];R[4]=R[8];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1923:if(acc==4){R[7]=G(R[1],2);ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1924:if(acc==3){if(R[4]==INULL){R[6]=ITRUE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{R[6]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[5];fp[3]=R[3];fp[2]=R[4];R[3]=(word)fp;fp+=5;ob=(word *)R[6];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1925:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[1],3);R[3]=IFALSE;ob=(word *)R[4];acc=1;}else{R[4]=G(R[1],2);assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);R[6]=G(R[1],4);R[3]=G(R[1],3);R[4]=R[5];R[5]=R[6];ob=(word *)R[5];acc=3;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1926:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1927:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);assert(pairp(R[5]),R[5],1053);R[6]=G(R[5],2);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1928:if(acc==2){assert(pairp(R[4]),R[4],1053);R[5]=G(R[4],2);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1929:if(acc==2){assert(pairp(R[4]),R[4],1052);R[5]=G(R[4],1);assert(pairp(R[5]),R[5],1052);R[6]=G(R[5],1);ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1930:if(acc==2){R[5]=INULL;R[6]=(R[4]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1931:if(acc==2){{word ob=R[4];if(allocp(ob))ob=V(ob);R[5]=F((ob>>TPOS)&63);}R[6]=F(1);R[7]=(R[6]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1932:if(acc==2){R[5]=ITRUE;if(R[4]==R[5]){ob=(word *)R[3];R[3]=R[5];acc=1;}else{if(R[4]==IFALSE){ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[6]=IFALSE;ob=(word *)R[3];R[3]=R[6];acc=1;}}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1933:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);R[8]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1934:if(acc==3){R[6]=G(R[1],2);R[7]=F(5);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1935:if(acc==3){R[6]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1936:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],2);*fp=make_header(3,TPROC);fp[1]=G(R[2],3);fp[2]=R[5];R[3]=(word)fp;fp+=3;R[7]=G(R[1],3);*fp=make_header(3,TPROC);fp[1]=G(R[2],4);fp[2]=R[7];R[8]=(word)fp;fp+=3;R[7]=R[4];R[4]=R[8];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1937:if(acc==2){R[5]=F(1);R[6]=prim_ref(R[4],R[5]);R[7]=G(R[1],2);R[8]=(R[6]==R[7])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[8];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1938:if(acc==1){R[4]=F(2);R[3]=prim_ref(R[3],R[4]);R[6]=G(R[1],2);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1939:if(acc==1){R[4]=G(R[1],5);R[5]=G(R[1],4);R[6]=G(R[1],3);R[7]=G(R[1],2);R[10]=R[5];R[5]=R[6];R[6]=R[7];R[7]=R[4];R[4]=R[3];R[3]=R[10];ob=(word *)R[7];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1940:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],4);fp[2]=R[4];R[5]=(word)fp;fp+=3;R[6]=G(R[1],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],3);fp[3]=R[5];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1941:if(acc==4){R[7]=G(R[1],2);*fp=make_header(6,TCLOS);fp[1]=G(R[2],2);fp[5]=R[3];fp[4]=R[4];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1942:if(acc==1){if(R[3]==IFALSE){R[4]=G(R[2],2);R[5]=G(R[1],2);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],3);*fp=make_header(6,TPROC);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=6;ob=(word *)R[4];acc=1;}else{R[4]=G(R[2],4);R[5]=G(R[1],4);R[6]=G(R[1],5);*fp=make_header(4,TPROC);fp[1]=G(R[2],5);fp[3]=R[6];fp[2]=R[5];R[3]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[4]=R[8];ob=(word *)R[9];acc=2;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1943:if(acc==1){R[4]=G(R[1],3);R[3]=G(R[1],2);ob=(word *)R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1944:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=3;R[7]=G(R[1],5);R[8]=G(R[1],4);R[4]=R[3];R[5]=R[6];R[6]=R[7];R[3]=R[8];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1945:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[6]=INULL;R[9]=R[5];R[5]=R[6];R[6]=R[4];R[4]=R[3];R[3]=R[9];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1946:if(acc==1){R[4]=G(R[1],2);R[5]=F(13);R[6]=IFALSE;R[9]=R[4];R[4]=R[5];R[5]=R[6];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1947:if(acc==2){R[5]=G(R[1],2);*fp=make_header(4,TCLOS);fp[1]=G(R[1],3);fp[3]=R[3];fp[2]=R[4];R[6]=(word)fp;fp+=4;R[7]=F(19);R[9]=R[5];R[5]=R[4];R[3]=R[6];R[6]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1948:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[7]=R[4];R[3]=R[5];R[4]=R[6];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1949:if(acc==3){R[6]=G(R[1],2);R[7]=F(9);R[9]=R[6];R[6]=R[5];R[5]=R[4];R[4]=R[7];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1950:if(acc==2){R[5]=G(R[1],2);R[6]=F(6);R[9]=R[5];R[10]=R[6];R[5]=R[4];R[6]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1951:if(acc==2){R[5]=G(R[1],2);R[6]=F(2);R[9]=R[5];R[10]=R[6];R[5]=R[4];R[6]=R[4];R[4]=R[10];ob=(word *)R[9];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1952:if(acc==4){R[7]=G(R[1],2);*fp=make_header(5,TPROC);fp[1]=G(R[1],3);fp[4]=R[4];fp[3]=R[5];fp[2]=R[6];R[4]=(word)fp;fp+=5;ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1953:if(acc==2){R[5]=G(R[1],2);*fp=make_header(3,TCLOS);fp[1]=G(R[1],3);fp[2]=R[3];R[6]=(word)fp;fp+=3;R[7]=F(63);R[8]=R[5];R[3]=R[6];R[5]=R[7];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1954:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[8]=R[5];R[5]=R[4];R[4]=R[3];R[3]=R[8];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1955:if(acc==2){*fp=make_header(3,TCLOS);fp[1]=G(R[1],2);fp[2]=R[3];R[5]=(word)fp;fp+=3;R[7]=R[4];R[4]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1956:if(acc==2){R[5]=G(R[1],2);R[6]=F(6);R[10]=R[5];R[11]=R[6];R[5]=R[4];R[6]=R[4];R[7]=R[4];R[4]=R[11];ob=(word *)R[10];acc=5;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1957:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[7];fp[4]=R[6];fp[3]=R[3];fp[2]=R[5];R[3]=(word)fp;fp+=6;R[9]=G(R[1],2);R[7]=R[4];R[4]=R[9];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1958:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[9]=R[6];R[10]=R[5];R[5]=R[3];R[6]=R[4];R[4]=R[9];R[3]=R[10];ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1959:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);R[11]=G(R[1],9);*fp=make_header(9,TCLOS);fp[1]=G(R[2],3);fp[8]=R[11];fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[12]=(word)fp;fp+=9;R[13]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[12];R[4]=R[13];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1960:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);R[10]=G(R[1],8);*fp=make_header(8,TCLOS);fp[1]=G(R[2],3);fp[7]=R[10];fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[11]=(word)fp;fp+=8;R[12]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[11];R[4]=R[12];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1961:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);R[9]=G(R[1],7);*fp=make_header(7,TCLOS);fp[1]=G(R[2],3);fp[6]=R[9];fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[10]=(word)fp;fp+=7;R[11]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[10];R[4]=R[11];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1962:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);R[8]=G(R[1],6);*fp=make_header(6,TCLOS);fp[1]=G(R[2],3);fp[5]=R[8];fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[9]=(word)fp;fp+=6;R[10]=G(R[1],2);R[8]=R[4];R[5]=R[3];R[3]=R[9];R[4]=R[10];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1963:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);R[7]=G(R[1],5);*fp=make_header(5,TCLOS);fp[1]=G(R[2],3);fp[4]=R[7];fp[3]=R[6];fp[2]=R[5];R[8]=(word)fp;fp+=5;R[9]=G(R[1],2);R[10]=R[4];R[5]=R[3];R[3]=R[8];R[4]=R[9];ob=(word *)R[10];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1964:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],4);*fp=make_header(4,TCLOS);fp[1]=G(R[2],3);fp[3]=R[6];fp[2]=R[5];R[7]=(word)fp;fp+=4;R[8]=G(R[1],2);R[9]=R[4];R[5]=R[3];R[3]=R[7];R[4]=R[8];ob=(word *)R[9];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1965:if(acc==1){R[4]=G(R[2],2);R[5]=G(R[1],3);R[6]=G(R[1],2);R[8]=R[4];R[9]=R[5];R[5]=R[3];R[4]=R[6];R[3]=R[9];ob=(word *)R[8];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1966:if(acc==1){R[4]=G(R[1],4);R[5]=G(R[1],3);R[6]=G(R[1],2);R[3]=R[5];R[5]=R[4];R[4]=R[6];ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1967:if(acc==2){R[5]=G(R[1],2);ob=(word *)R[5];acc=3;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1968:if(acc==4){if(R[4]==INULL){ob=(word *)R[3];R[3]=R[5];acc=1;}else{assert(pairp(R[4]),R[4],1052);R[7]=G(R[4],1);R[4]=G(R[4],2);*fp=make_header(4,TPROC);fp[1]=G(R[1],2);fp[3]=R[3];fp[2]=R[7];R[3]=(word)fp;fp+=4;ob=(word *)R[6];acc=4;}}else{{error(17,ob,F(acc));}}break; /* # */ + case 1969:if(acc==1){R[4]=G(R[1],2);*fp=PAIRHDR;fp[1]=R[4];fp[2]=R[3];R[3]=(word)fp;fp+=3;R[6]=G(R[1],3);ob=(word *)R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1970:if(acc==3){R[6]=G(R[1],2);ob=(word *)R[6];acc=4;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1971:if(acc==2){R[5]=(immediatep(R[4]))?IFALSE:F(hdrsize(V(R[4]))-1);R[6]=IFALSE;R[7]=(R[6]==R[5])?ITRUE:IFALSE;ob=(word *)R[3];R[3]=R[7];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1972:if(acc==2){ob=(word *)R[3];R[3]=R[4];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1973:if(acc==3){*fp=make_header(4,TCLOS);fp[1]=G(R[1],2);fp[3]=R[4];fp[2]=R[5];R[6]=(word)fp;fp+=4;ob=(word *)R[3];R[3]=R[6];acc=1;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1974:if(acc==2){R[5]=G(R[1],2);R[6]=G(R[1],3);*fp=make_header(4,TPROC);fp[1]=G(R[2],2);fp[3]=R[6];fp[2]=R[3];R[3]=(word)fp;fp+=4;ob=(word *)R[5];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1975:if(acc==1){R[4]=G(R[1],3);R[5]=G(R[1],2);R[7]=R[4];R[4]=R[3];R[3]=R[5];ob=(word *)R[7];acc=2;}else{{error(17,ob,F(acc));}}break; /* # */ + case 1976:if(acc==2){if(R[4]==IFALSE){R[5]=ITRUE;ob=(word *)R[3];R[3]=R[5];acc=1;}else{R[5]=IFALSE;ob=(word *)R[3];R[3]=R[5];acc=1;}}else{{error(17,ob,F(acc));}}break; /* # */ + + default: + error(258, F(op), ITRUE); + } + goto apply; + +invoke_mcp: /* R4-R6 set, set R3=cont and R4=syscall and call mcp */ + ob = (word *) R[0]; + R[0] = IFALSE; + R[3] = F(3); + if (allocp(ob)) { + acc = 4; + goto apply; + } + return 1; /* no mcp to handle error (fail in it?), so nonzero exit */ +} + +#pragma clang diagnostic pop diff --git a/third_party/radamsa/radamsa.cc b/third_party/radamsa/radamsa.cc new file mode 100644 index 0000000..bf6894a --- /dev/null +++ b/third_party/radamsa/radamsa.cc @@ -0,0 +1,121 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#include "../../third_party/radamsa/radamsa.h" + +#include + +#include +#include +#include +#include "../../third_party/xxhash/xxhash.h" + +namespace radamsa { +namespace { + +static struct X { + // Input/output to Radamsa. + const std::string *input; + std::string output; + + // Where are we in the process of reading `input`? + size_t input_index; + + // Set of objects that remain unfreed by Radamsa. + std::set allocations; + +} gRadamsa; + +// Radamsa's `main` function. +extern "C" void *radamsa_boot(int argc, const char *argv[]); + +// Pretend to do a `read` system call from within Radamsa. +extern "C" ssize_t radamsa_read(int, uint8_t *buff, size_t buff_size) { + auto count = std::min( + buff_size, gRadamsa.input->length() - gRadamsa.input_index); + + memcpy(buff, gRadamsa.input->data() + gRadamsa.input_index, count); + gRadamsa.input_index += count; + return static_cast(count); +} + +// Pretend to do a `write` system call from within Radamsa. +extern "C" ssize_t radamsa_write(int, uint8_t *buff, size_t buff_size) { + gRadamsa.output.insert(gRadamsa.output.end(), buff, buff + buff_size); + return static_cast(buff_size); +} + +// Interposes on `malloc`s performed by Radamsa. +extern "C" void *radamsa_malloc(size_t size) { + auto ptr = malloc(size); + gRadamsa.allocations.insert(ptr); + return ptr; +} + +// Interposes on `free`s performed by Radamsa. +extern "C" void radamsa_free(void *ptr) { + gRadamsa.allocations.erase(ptr); + free(ptr); +} + +// Interposes on `realloc`s performed by Radamsa. The OWL scheme compiler uses +// `realloc` for heap allocation. +extern "C" void *radamsa_realloc(void *ptr, size_t size) { + gRadamsa.allocations.erase(ptr); + ptr = realloc(ptr, size); + gRadamsa.allocations.insert(ptr); + return ptr; +} + +static inline uint64_t CurrentTSC(void) { + uint64_t x; + __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)); + return x; +} + +static XXH64_state_t gRadamsaRandState; +static auto gRadamsaRandStateInitialized = false; +static char gRadamsaSeed[32] = {'\0'}; +} // namespace + +std::string Mutate(const std::string &input) { + if (!gRadamsaRandStateInitialized) { + gRadamsaRandStateInitialized = true; + XXH64_reset(&gRadamsaRandState, CurrentTSC()); + } + + XXH64_update(&gRadamsaRandState, input.data(), input.size()); + + gRadamsa.input = &input; + gRadamsa.input_index = 0; + gRadamsa.output.clear(); + gRadamsa.output.reserve(input.size()); + + sprintf(gRadamsaSeed, "%ld", XXH64_digest(&gRadamsaRandState) & 0xFFFFFFFFU); + + const char *args[] = { + "radamsa", + "--seed", + gRadamsaSeed, + nullptr + }; +#if 1 + // I am not sure if this is even valid, due to the Radamsa heap being a + // static char array. + radamsa_boot(3, args); +#else + pthread_t radamsa; + pthread_create(&radamsa, nullptr, radamsa_boot, nullptr); + pthread_join(radamsa, nullptr); +#endif + + for (auto ptr : gRadamsa.allocations) free(ptr); + + gRadamsa.input = nullptr; + gRadamsa.allocations.clear(); + + std::string output; + output.swap(gRadamsa.output); + return output; +} + +} // namespace fuzz diff --git a/third_party/radamsa/radamsa.h b/third_party/radamsa/radamsa.h new file mode 100644 index 0000000..d608ed4 --- /dev/null +++ b/third_party/radamsa/radamsa.h @@ -0,0 +1,16 @@ +/* Copyright 2015 Peter Goodman, all rights reserved. */ + +#ifndef THIRD_PARTY_RADAMSA_RADAMSA_H_ +#define THIRD_PARTY_RADAMSA_RADAMSA_H_ + +#include "granary/base/base.h" + +#include + +namespace radamsa { + +std::string Mutate(const std::string &input); + +} // namespace radamsa + +#endif // THIRD_PARTY_RADAMSA_RADAMSA_H_ diff --git a/third_party/xed-intel64/BUG-REPORTS.txt b/third_party/xed-intel64/BUG-REPORTS.txt new file mode 100644 index 0000000..6f341cc --- /dev/null +++ b/third_party/xed-intel64/BUG-REPORTS.txt @@ -0,0 +1,2 @@ +Send bugs to mark.charney@intel.com + diff --git a/third_party/xed-intel64/LICENSE.txt b/third_party/xed-intel64/LICENSE.txt new file mode 100644 index 0000000..8243578 --- /dev/null +++ b/third_party/xed-intel64/LICENSE.txt @@ -0,0 +1,144 @@ +IMPORTANT - READ BEFORE COPYING, INSTALLING OR USING. + +Do not copy, install, or use the "Materials" provided under this +license agreement ("Agreement"), until you have carefully read the +following terms and conditions. By copying, installing, or otherwise +using the Materials, you agree to be bound by the terms of this +Agreement. If you do not agree to the terms of this Agreement, do not +copy, install, or use the Materials. + +Pre-Release License Agreement for Pre-Release Software + +1. PRE-RELEASE: The Materials are pre-release code, which may not be +fully functional and which Intel may substantially modify in producing +any final version. Intel can provide no assurance that it will ever +produce or make generally available a final version. + +2. LICENSE DEFINITIONS: + +A. "Materials" are defined as the software, documentation, license key +codes and other materials, including any updates and upgrade thereto, +for the applicable pre-release software (which may be found at +http://whatif.intel.com/), that are provided to you under this +Agreement. + +3. LICENSE GRANT: + +A. Subject to all of the terms and conditions of this Agreement, Intel +Corporation ("Intel") grants to you a non-exclusive, non-assignable +copyright license to make only the minimum number of copies of the +Materials reasonably necessary for your internal testing and +development of your products. + +B. Subject to all of the terms and conditions of this Agreement, Intel +grants to you a non-exclusive, non-assignable copyright license to +modify the Materials that are provided in source code (human readable) +form. + +C. If the Materials include the file named 'redist.txt', then subject +to all of the terms and conditions of this Agreement and any specific +restrictions which may appear in the 'redist.txt' file, Intel grants +to you a non-exclusive, non-assignable copyright license to +redistribute the files (unmodified or modified by you) listed in the +'redist.txt' file only as part of the application you develop with the +Materials. + +4. LICENSE RESTRICTIONS: + +A. You may not reverse-assemble, reverse-compile, or otherwise +reverse-engineer any software provided solely in binary form. + +B. You may not distribute any portion of Materials, whether in source +or binary form, to any third party, except as specified in this +Agreement. + +5. COPYRIGHT: Title to the Materials and all copies thereof remain +with Intel or its suppliers. The Materials are copyrighted and are +protected by United States copyright laws and international treaty +provisions. You will not remove any copyright notice from the +Materials. You agree to prevent any unauthorized copying of the +Materials. Except as expressly provided herein, Intel does not grant +any express or implied right to you under Intel patents, copyrights, +trademarks, or trade secret information. Subject to Intel's ownership +of the Materials, all right, title and interest in and to your +modifications shall belong to you. + +6. REPLACEMENTS: The Materials are provided "AS IS" without warranty +of any kind. If the media on which the Materials are furnished are +found to be defective in material or workmanship under normal use for +a period of ninety (90) days from the date of receipt, Intel's entire +liability and your exclusive remedy shall be the replacement of the +media. This offer is void if the media defect results from accident, +abuse, or misapplication. + +7. LIMITATION OF LIABILITY: THE ABOVE REPLACEMENT PROVISION IS THE +ONLY WARRANTY OF ANY KIND. INTEL OFFERS NO OTHER WARRANTY EITHER +EXPRESS OR IMPLIED INCLUDING THOSE OF MERCHANTABILITY, NONINFRINGEMENT +OF THIRD- PARTY INTELLECTUAL PROPERTY OR FITNESS FOR A PARTICULAR +PURPOSE. NEITHER INTEL NOR ITS SUPPLIERS SHALL BE LIABLE FOR ANY +DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF +BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, +OR OTHER LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE THE +SOFTWARE, EVEN IF INTEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. BECAUSE SOME JURISDICTIONS PROHIBIT THE EXCLUSION OR +LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE +ABOVE LIMITATION MAY NOT APPLY TO YOU. + +8. UNAUTHORIZED USE: THE MATERIALS ARE NOT DESIGNED, INTENDED, OR +AUTHORIZED FOR USE IN ANY TYPE OF SYSTEM OR APPLICATION IN WHICH THE +FAILURE OF THE MATERIALS COULD CREATE A SITUATION WHERE PERSONAL +INJURY OR DEATH MAY OCCUR (E.G MEDICAL SYSTEMS, LIFE SUSTAINING OR +LIFE SAVING SYSTEMS). Should the buyer purchase or use the Materials +for any such unintended or unauthorized use, the buyer shall indemnify +and hold Intel and its officers, subsidiaries and affiliates harmless +against all claims, costs, damages, and expenses, and reasonable +attorney fees arising out of, directly or indirectly, any claim of +product liability, personal injury or death associated with such +unintended or unauthorized use, even if such claim alleges that Intel +was negligent regarding the design or manufacture of the part. + +9. USER SUBMISSIONS: You agree that any material, information or other +communication, including all data, images, sounds, text, and other +things embodied therein, you transmit or post to an Intel website or +provide to Intel under this Agreement will be considered +non-confidential ("Communications"). Intel will have no +confidentiality obligations with respect to the Communications. You +agree that Intel and its designees will be free to copy, modify, +create derivative works, publicly display, disclose, distribute, +license and sublicense through multiple tiers of distribution and +licensees, incorporate and otherwise use the Communications, including +derivative works thereto, for any and all commercial or non-commercial +purposes. + +10. TERMINATION OF THIS LICENSE: The term of this Agreement will +commence on the date this Agreement is accepted by You and will +continue until terminated. This Agreement will terminate without +notice on the last day of the pre-release period, which is specified +elsewhere in the Materials, or upon the commercial release of the +Materials. Intel may terminate this Agreement at any time, with or +without cause, with written notice to you. Upon termination, you will +immediately destroy the Materials or return all copies of the +Materials to Intel along with any copies you have made. + +11. U.S. GOVERNMENT RESTRICTED RIGHTS: The Materials are provided with +"RESTRICTED RIGHTS". Use, duplication or disclosure by the Government +is subject to restrictions set forth in FAR52.227-14 and +DFAR252.227-7013 et seq. or its successor. Use of the Materials by the +Government constitutes acknowledgment of Intel's rights in them. + +12. EXPORT RESTRICTED RIGHTS: This software is subject to the +U.S. Export Administration Regulations and other U.S. law, and may not +be exported or re-exported to certain countries (Burma, Cuba, Iran, +North Korea, Sudan, and Syria) or to persons or entities prohibited +from receiving U.S. exports (including Denied Parties, Specially +Designated Nationals, and entities on the Bureau of Export +Administration Entity List or involved with missile technology or +nuclear, chemical or biological weapons). + +13. APPLICABLE LAWS: Any claim arising under or relating to this +Agreement shall be governed by the internal substantive laws of the +State of Delaware or federal courts located in Delaware, without +regard to principles of conflict of laws. You may not export the +Materials in violation of applicable export laws. + +* Other names and brands may be claimed as the property of others diff --git a/third_party/xed-intel64/README.txt b/third_party/xed-intel64/README.txt new file mode 100644 index 0000000..d2adcf1 --- /dev/null +++ b/third_party/xed-intel64/README.txt @@ -0,0 +1,148 @@ +Documentation: + +Internal Intel: http://sde.intel.com/xed +External World: http://software.intel.com/en-us/articles/pintool-downloads + +Send bugs to mark.charney@intel.com + + +================================================================================ + +If you are programming: + +decoder: look at examples/xed-ex1.cpp +encoder: look at examples/xed-ex5-enc.c (for the high-level encoder API) + +================================================================================ + +Examples of using hte command line tool: + +% obj/xed -h +Copyright (C) 2003-2014, Intel Corporation. All rights reserved. +XED version: [6.26.0-5-gb6a5c90 2014-04-17] + +Usage: obj/xed [options] +One of the following is required: + -i input_file (decode file) + -ir raw_input_file (decode a raw unformatted binary file) + -ih hex_input_file (decode a raw unformatted ASCII hex file) + -d hex-string (decode one instruction, must be last) + -ide input_file (decode/encode file) + -e instruction (encode, must be last) + -ie file-to-assemble (assemble the contents of the file) + -de hex-string (decode-then-encode, must be last) + +Optional arguments: + + -v N (0=quiet, 1=errors, 2=useful-info, 3=trace, + 5=very verbose) + -xv N (XED engine verbosity, 0...99) + + -chip-check CHIP (count instructions that are not valid for CHIP) + -chip-check-list (list the valid chips) + + -s section (target section for file disassembly, + PECOFF and ELF formats only) + + -n N (number of instructions to decode. Default 100M, + accepts K/M/G qualifiers) + + -perftail N (number of instructions to skip in performance + measurements. Default 0, accepts K/M/G qualifiers) + + -b addr (Base address offset, for DLLs/shared libraries. + Use 0x for hex addresses) + -as addr (Address to start disassembling. + Use 0x for hex addresses) + -ae addr (Address to end disassembling. + Use 0x for hex addresses) + -no-resync (Disable symbol-based resynchronization algorithm + for disassembly) + -ast (Show the AVX/SSE transition classfication) + + -I (Intel syntax for disassembly) + -A (ATT SYSV syntax for disassembly) + -xml (XML formatting) + -nwm (Format AVX512 without curly braces for writemasks, include k0) + -emit (Output __emit statements for the Intel compiler) + -dot FN (Emit a register dependence graph file in dot format. + Best used with -as ADDR -ae ADDR to limit graph size.) + + -r (for REAL_16 mode, 16b addressing (20b addresses), + 16b default data size) + -16 (for LEGACY_16 mode, 16b addressing, + 16b default data size) + -32 (for LEGACY_32 mode, 32b addressing, + 32b default data size -- default) + -64 (for LONG_64 mode w/64b addressing + Optional on windows/linux) + -mpx (Turn on MPX mode for disassembly, default is off) + -s32 (32b stack addressing, default, not in LONG_64 mode) + -s16 (16b stack addressing, not in LONG_64 mode) + + +================================================================================ + +Examples of use: + +Disassemble a file + +% obj/xed -i /bin/ls > dis.txt +% obj/xed -i foo.o > dis.txt + + +Disassemble an instruction: + +% obj/xed -64 -d 00 00 +0000 +ICLASS: ADD CATEGORY: BINARY EXTENSION: BASE IFORM: ADD_MEMb_GPR8 ISA_SET: I86 +SHORT: add byte ptr [rax], al + + +Encode an instruction (only some features available) + +% obj/xed -64 -e vaddps xmm1 xmm2 xmm3 +Request: VADDPS MODE:2, REG0:XMM1, REG1:XMM2, REG2:XMM3, SMODE:2 +OPERAND ORDER: REG0 REG1 REG2 +Encodable! C5E858CB +.byte 0xc5,0xe8,0x58,0xcb + + +Decode and then re-encode an instruction: + +% obj/xed -64 -de C5E858CB +C5E858CB +ICLASS: VADDPS CATEGORY: AVX EXTENSION: AVX IFORM: VADDPS_XMMdq_XMMdq_XMMdq ISA_SET: AVX +SHORT: vaddps xmm1, xmm2, xmm3 +Encodable! C5E858CB +Identical re-encoding + + +Find out detailed information about an instruction: + + +% obj/xed-ex1 -64 C5E858CB +Attempting to decode: c5 e8 58 cb +iclass VADDPS category AVX ISA-extension AVX ISA-set AVX +instruction-length 4 +operand-width 32 +effective-operand-width 32 +effective-address-width 64 +stack-address-width 64 +iform-enum-name VADDPS_XMMdq_XMMdq_XMMdq +iform-enum-name-dispatch (zero based) 1 +iclass-max-iform-dispatch 10 +Operands +# TYPE DETAILS VIS RW OC2 BITS BYTES NELEM ELEMSZ ELEMTYPE +# ==== ======= === == === ==== ===== ===== ====== ======== +0 REG0 REG0=XMM1 EXPLICIT W DQ 128 16 4 32 SINGLE +1 REG1 REG1=XMM2 EXPLICIT R DQ 128 16 4 32 SINGLE +2 REG2 REG2=XMM3 EXPLICIT R DQ 128 16 4 32 SINGLE +Memory Operands + MemopBytes = 0 +ATTRIBUTES: MXCSR +EXCEPTION TYPE: AVX_TYPE_2 +Vector length: 128 + + +================================================================================ diff --git a/third_party/xed-intel64/include/xed-address-width-enum.h b/third_party/xed-intel64/include/xed-address-width-enum.h new file mode 100644 index 0000000..ab682bf --- /dev/null +++ b/third_party/xed-intel64/include/xed-address-width-enum.h @@ -0,0 +1,63 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-address-width-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ADDRESS_WIDTH_ENUM_H_) +# define _XED_ADDRESS_WIDTH_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_ADDRESS_WIDTH_INVALID=0, + XED_ADDRESS_WIDTH_16b=2, ///< 16b addressing + XED_ADDRESS_WIDTH_32b=4, ///< 32b addressing + XED_ADDRESS_WIDTH_64b=8, ///< 64b addressing + XED_ADDRESS_WIDTH_LAST +} xed_address_width_enum_t; + +/// This converts strings to #xed_address_width_enum_t types. +/// @param s A C-string. +/// @return #xed_address_width_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_address_width_enum_t str2xed_address_width_enum_t(const char* s); +/// This converts strings to #xed_address_width_enum_t types. +/// @param p An enumeration element of type xed_address_width_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_address_width_enum_t2str(const xed_address_width_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_address_width_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_address_width_enum_t xed_address_width_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-agen.h b/third_party/xed-intel64/include/xed-agen.h new file mode 100644 index 0000000..f89f99f --- /dev/null +++ b/third_party/xed-intel64/include/xed-agen.h @@ -0,0 +1,74 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-agen.h +/// + + +#ifndef _XED_AGEN_H_ +# define _XED_AGEN_H_ +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-error-enum.h" + + +/// A function for obtaining register values. 32b return values should be +/// zero extended to 64b. The error value is set to nonzero if the callback +/// experiences some sort of problem. @ingroup AGEN +typedef xed_uint64_t (*xed_register_callback_fn_t)(xed_reg_enum_t reg, void* context, xed_bool_t* error); + +/// A function for obtaining the segment base values. 32b return values +/// should be zero extended zero extended to 64b. The error value is set to +/// nonzero if the callback experiences some sort of problem. +/// @ingroup AGEN +typedef xed_uint64_t (*xed_segment_base_callback_fn_t)(xed_reg_enum_t reg, void* context, xed_bool_t* error); + + +/// Initialize the callback functions. Tell XED what to call when using +/// #xed_agen. +/// @ingroup AGEN +XED_DLL_EXPORT void xed_agen_register_callback(xed_register_callback_fn_t register_fn, + xed_segment_base_callback_fn_t segment_fn); + +/// Using the registered callbacks, compute the memory address for a +/// specified memop in a decoded instruction. memop_index can have the +/// value 0 for XED_OPERAND_MEM0, XED_OPERAND_AGEN, or 1 for +/// XED_OPERAND_MEM1. Any other value results in an error being +/// returned. The context parameter which is passed to the registered +/// callbacks can be used to identify which thread's state is being +/// referenced. +/// @ingroup AGEN +XED_DLL_EXPORT xed_error_enum_t xed_agen(xed_decoded_inst_t* xedd, + unsigned int memop_index, + void* context, + xed_uint64_t* out_address); + + +#endif diff --git a/third_party/xed-intel64/include/xed-attribute-enum.h b/third_party/xed-intel64/include/xed-attribute-enum.h new file mode 100644 index 0000000..d6360fa --- /dev/null +++ b/third_party/xed-intel64/include/xed-attribute-enum.h @@ -0,0 +1,146 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-attribute-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ATTRIBUTE_ENUM_H_) +# define _XED_ATTRIBUTE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_ATTRIBUTE_INVALID, + XED_ATTRIBUTE_ATT_OPERAND_ORDER_EXCEPTION, + XED_ATTRIBUTE_AVX_REQUIRES_ALIGNMENT, + XED_ATTRIBUTE_BROADCAST_ENABLED, + XED_ATTRIBUTE_BYTEOP, + XED_ATTRIBUTE_DISP8_EIGHTHMEM, + XED_ATTRIBUTE_DISP8_FULL, + XED_ATTRIBUTE_DISP8_FULLMEM, + XED_ATTRIBUTE_DISP8_GPR_READER, + XED_ATTRIBUTE_DISP8_GPR_READER_BYTE, + XED_ATTRIBUTE_DISP8_GPR_READER_WORD, + XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_D, + XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_Q, + XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE, + XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_BYTE, + XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_WORD, + XED_ATTRIBUTE_DISP8_GSCAT, + XED_ATTRIBUTE_DISP8_HALF, + XED_ATTRIBUTE_DISP8_HALFMEM, + XED_ATTRIBUTE_DISP8_MEM128, + XED_ATTRIBUTE_DISP8_MOVDDUP, + XED_ATTRIBUTE_DISP8_QUARTERMEM, + XED_ATTRIBUTE_DISP8_SCALAR, + XED_ATTRIBUTE_DISP8_TUPLE1, + XED_ATTRIBUTE_DISP8_TUPLE1_BYTE, + XED_ATTRIBUTE_DISP8_TUPLE1_WORD, + XED_ATTRIBUTE_DISP8_TUPLE2, + XED_ATTRIBUTE_DISP8_TUPLE4, + XED_ATTRIBUTE_DISP8_TUPLE8, + XED_ATTRIBUTE_DOUBLE_WIDE_MEMOP, + XED_ATTRIBUTE_DOUBLE_WIDE_OUTPUT, + XED_ATTRIBUTE_DWORD_INDICES, + XED_ATTRIBUTE_ELEMENT_SIZE_D, + XED_ATTRIBUTE_ELEMENT_SIZE_Q, + XED_ATTRIBUTE_EXCEPTION_BR, + XED_ATTRIBUTE_FAR_XFER, + XED_ATTRIBUTE_FIXED_BASE0, + XED_ATTRIBUTE_FIXED_BASE1, + XED_ATTRIBUTE_GATHER, + XED_ATTRIBUTE_HALF_WIDE_OUTPUT, + XED_ATTRIBUTE_HLE_ACQ_ABLE, + XED_ATTRIBUTE_HLE_REL_ABLE, + XED_ATTRIBUTE_IGNORES_OSFXSR, + XED_ATTRIBUTE_IMPLICIT_ONE, + XED_ATTRIBUTE_INDEX_REG_IS_POINTER, + XED_ATTRIBUTE_KMASK, + XED_ATTRIBUTE_LOCKABLE, + XED_ATTRIBUTE_LOCKED, + XED_ATTRIBUTE_MASKOP, + XED_ATTRIBUTE_MASKOP_EVEX, + XED_ATTRIBUTE_MASK_AS_CONTROL, + XED_ATTRIBUTE_MASK_VARIABLE_MEMOP, + XED_ATTRIBUTE_MEMORY_FAULT_SUPPRESSION, + XED_ATTRIBUTE_MMX_EXCEPT, + XED_ATTRIBUTE_MPX_PREFIX_ABLE, + XED_ATTRIBUTE_MXCSR, + XED_ATTRIBUTE_MXCSR_RD, + XED_ATTRIBUTE_NOP, + XED_ATTRIBUTE_NOTSX, + XED_ATTRIBUTE_NOTSX_COND, + XED_ATTRIBUTE_NO_RIP_REL, + XED_ATTRIBUTE_PREFETCH, + XED_ATTRIBUTE_PROTECTED_MODE, + XED_ATTRIBUTE_QWORD_INDICES, + XED_ATTRIBUTE_REP, + XED_ATTRIBUTE_REQUIRES_ALIGNMENT, + XED_ATTRIBUTE_RING0, + XED_ATTRIBUTE_SCALABLE, + XED_ATTRIBUTE_SCATTER, + XED_ATTRIBUTE_SIMD_PACKED_ALIGNMENT, + XED_ATTRIBUTE_SIMD_SCALAR, + XED_ATTRIBUTE_SKIPLOW32, + XED_ATTRIBUTE_SKIPLOW64, + XED_ATTRIBUTE_SPECIAL_AGEN_REQUIRED, + XED_ATTRIBUTE_STACKPOP0, + XED_ATTRIBUTE_STACKPOP1, + XED_ATTRIBUTE_STACKPUSH0, + XED_ATTRIBUTE_STACKPUSH1, + XED_ATTRIBUTE_UNALIGNED, + XED_ATTRIBUTE_X87_CONTROL, + XED_ATTRIBUTE_X87_MMX_STATE_CW, + XED_ATTRIBUTE_X87_MMX_STATE_R, + XED_ATTRIBUTE_X87_MMX_STATE_W, + XED_ATTRIBUTE_X87_NOWAIT, + XED_ATTRIBUTE_XMM_STATE_CW, + XED_ATTRIBUTE_XMM_STATE_R, + XED_ATTRIBUTE_XMM_STATE_W, + XED_ATTRIBUTE_LAST +} xed_attribute_enum_t; + +/// This converts strings to #xed_attribute_enum_t types. +/// @param s A C-string. +/// @return #xed_attribute_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_attribute_enum_t str2xed_attribute_enum_t(const char* s); +/// This converts strings to #xed_attribute_enum_t types. +/// @param p An enumeration element of type xed_attribute_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_attribute_enum_t2str(const xed_attribute_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_attribute_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_attribute_enum_t xed_attribute_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-attributes.h b/third_party/xed-intel64/include/xed-attributes.h new file mode 100644 index 0000000..9a1fa61 --- /dev/null +++ b/third_party/xed-intel64/include/xed-attributes.h @@ -0,0 +1,42 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#if !defined(_XED_ATTRIBUTES_H_) +# define _XED_ATTRIBUTES_H_ +#include "../../../third_party/xed-intel64/include/xed-types.h" + +typedef struct { + xed_uint64_t a1; + xed_uint64_t a2; +} xed_attributes_t; + +#endif diff --git a/third_party/xed-intel64/include/xed-build-defines.h b/third_party/xed-intel64/include/xed-build-defines.h new file mode 100644 index 0000000..d4b1e93 --- /dev/null +++ b/third_party/xed-intel64/include/xed-build-defines.h @@ -0,0 +1,53 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +#if !defined(_XED_BUILD_DEFINES_H_) +# define _XED_BUILD_DEFINES_H_ + +# if !defined(XED_AMD_ENABLED) +# define XED_AMD_ENABLED +# endif +# if !defined(XED_AVX) +# define XED_AVX +# endif +# if !defined(XED_GIT_VERSION) +# define XED_GIT_VERSION "7.22.0-19-gc0dc743 2015-04-10" +# endif +# if !defined(XED_MPX) +# define XED_MPX +# endif +# if !defined(XED_SUPPORTS_AVX512) +# define XED_SUPPORTS_AVX512 +# endif +# if !defined(XED_SUPPORTS_SHA) +# define XED_SUPPORTS_SHA +# endif +#endif diff --git a/third_party/xed-intel64/include/xed-category-enum.h b/third_party/xed-intel64/include/xed-category-enum.h new file mode 100644 index 0000000..26d6274 --- /dev/null +++ b/third_party/xed-intel64/include/xed-category-enum.h @@ -0,0 +1,134 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-category-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_CATEGORY_ENUM_H_) +# define _XED_CATEGORY_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_CATEGORY_INVALID, + XED_CATEGORY_3DNOW, + XED_CATEGORY_AES, + XED_CATEGORY_AVX, + XED_CATEGORY_AVX2, + XED_CATEGORY_AVX2GATHER, + XED_CATEGORY_AVX512, + XED_CATEGORY_AVX512VBMI, + XED_CATEGORY_BDW, + XED_CATEGORY_BINARY, + XED_CATEGORY_BITBYTE, + XED_CATEGORY_BLEND, + XED_CATEGORY_BMI1, + XED_CATEGORY_BMI2, + XED_CATEGORY_BROADCAST, + XED_CATEGORY_CALL, + XED_CATEGORY_CLFLUSHOPT, + XED_CATEGORY_CLWB, + XED_CATEGORY_CMOV, + XED_CATEGORY_COMPRESS, + XED_CATEGORY_COND_BR, + XED_CATEGORY_CONFLICT, + XED_CATEGORY_CONVERT, + XED_CATEGORY_DATAXFER, + XED_CATEGORY_DECIMAL, + XED_CATEGORY_EXPAND, + XED_CATEGORY_FCMOV, + XED_CATEGORY_FLAGOP, + XED_CATEGORY_FMA4, + XED_CATEGORY_GATHER, + XED_CATEGORY_IFMA, + XED_CATEGORY_INTERRUPT, + XED_CATEGORY_IO, + XED_CATEGORY_IOSTRINGOP, + XED_CATEGORY_KMASK, + XED_CATEGORY_LOGICAL, + XED_CATEGORY_LOGICAL_FP, + XED_CATEGORY_LZCNT, + XED_CATEGORY_MISC, + XED_CATEGORY_MMX, + XED_CATEGORY_MPX, + XED_CATEGORY_NOP, + XED_CATEGORY_PCLMULQDQ, + XED_CATEGORY_PCOMMIT, + XED_CATEGORY_POP, + XED_CATEGORY_PREFETCH, + XED_CATEGORY_PUSH, + XED_CATEGORY_RDRAND, + XED_CATEGORY_RDSEED, + XED_CATEGORY_RDWRFSGS, + XED_CATEGORY_RET, + XED_CATEGORY_ROTATE, + XED_CATEGORY_SCATTER, + XED_CATEGORY_SEGOP, + XED_CATEGORY_SEMAPHORE, + XED_CATEGORY_SETCC, + XED_CATEGORY_SGX, + XED_CATEGORY_SHA, + XED_CATEGORY_SHIFT, + XED_CATEGORY_SMAP, + XED_CATEGORY_SSE, + XED_CATEGORY_STRINGOP, + XED_CATEGORY_STTNI, + XED_CATEGORY_SYSCALL, + XED_CATEGORY_SYSRET, + XED_CATEGORY_SYSTEM, + XED_CATEGORY_TBM, + XED_CATEGORY_UNCOND_BR, + XED_CATEGORY_VFMA, + XED_CATEGORY_VTX, + XED_CATEGORY_WIDENOP, + XED_CATEGORY_X87_ALU, + XED_CATEGORY_XOP, + XED_CATEGORY_XSAVE, + XED_CATEGORY_XSAVEOPT, + XED_CATEGORY_LAST +} xed_category_enum_t; + +/// This converts strings to #xed_category_enum_t types. +/// @param s A C-string. +/// @return #xed_category_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_category_enum_t str2xed_category_enum_t(const char* s); +/// This converts strings to #xed_category_enum_t types. +/// @param p An enumeration element of type xed_category_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_category_enum_t2str(const xed_category_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_category_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_category_enum_t xed_category_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-chip-enum.h b/third_party/xed-intel64/include/xed-chip-enum.h new file mode 100644 index 0000000..2fe9fdd --- /dev/null +++ b/third_party/xed-intel64/include/xed-chip-enum.h @@ -0,0 +1,105 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-chip-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_CHIP_ENUM_H_) +# define _XED_CHIP_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_CHIP_INVALID, + XED_CHIP_I86, + XED_CHIP_I86FP, + XED_CHIP_I186, + XED_CHIP_I186FP, + XED_CHIP_I286REAL, + XED_CHIP_I286, + XED_CHIP_I2186FP, + XED_CHIP_I386REAL, + XED_CHIP_I386, + XED_CHIP_I386FP, + XED_CHIP_I486REAL, + XED_CHIP_I486, + XED_CHIP_PENTIUMREAL, + XED_CHIP_PENTIUM, + XED_CHIP_QUARK, + XED_CHIP_PENTIUMMMXREAL, + XED_CHIP_PENTIUMMMX, + XED_CHIP_ALLREAL, + XED_CHIP_PENTIUMPRO, + XED_CHIP_PENTIUM2, + XED_CHIP_PENTIUM3, + XED_CHIP_PENTIUM4, + XED_CHIP_P4PRESCOTT, + XED_CHIP_P4PRESCOTT_NOLAHF, + XED_CHIP_P4PRESCOTT_VTX, + XED_CHIP_CORE2, + XED_CHIP_PENRYN, + XED_CHIP_PENRYN_E, + XED_CHIP_NEHALEM, + XED_CHIP_WESTMERE, + XED_CHIP_BONNELL, + XED_CHIP_SALTWELL, + XED_CHIP_SILVERMONT, + XED_CHIP_AMD, + XED_CHIP_GOLDMONT, + XED_CHIP_SANDYBRIDGE, + XED_CHIP_IVYBRIDGE, + XED_CHIP_HASWELL, + XED_CHIP_BROADWELL, + XED_CHIP_SKYLAKE, + XED_CHIP_SKYLAKE_SERVER, + XED_CHIP_MEMORY_FUTURE, + XED_CHIP_KNL, + XED_CHIP_AVX512_FUTURE, + XED_CHIP_ALL, + XED_CHIP_LAST +} xed_chip_enum_t; + +/// This converts strings to #xed_chip_enum_t types. +/// @param s A C-string. +/// @return #xed_chip_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_chip_enum_t str2xed_chip_enum_t(const char* s); +/// This converts strings to #xed_chip_enum_t types. +/// @param p An enumeration element of type xed_chip_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_chip_enum_t2str(const xed_chip_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_chip_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_chip_enum_t xed_chip_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-common-defs.h b/third_party/xed-intel64/include/xed-common-defs.h new file mode 100644 index 0000000..c3ce6ea --- /dev/null +++ b/third_party/xed-intel64/include/xed-common-defs.h @@ -0,0 +1,81 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-common-defs.h +/// @brief some pervasive defines + + + +#ifndef _XED_COMMON_DEFS_H_ +# define _XED_COMMON_DEFS_H_ + +//////////////////////////////////////////////////////////////////////////// + +#define XED_MAX_OPERANDS 11 +#define XED_MAX_NONTERMINALS_PER_INSTRUCTION 20 // FIXME somewhat arbitrary + + // for most things it is 4, but one 64b mov allows 8 +#define XED_MAX_DISPLACEMENT_BYTES 8 + + // for most things it is max 4, but one 64b mov allows 8. +#define XED_MAX_IMMEDIATE_BYTES 8 + +#define XED_MAX_INSTRUCTION_BYTES 15 + + +#define XED_BYTE_MASK(x) ((x) & 0xFF) +#define XED_BYTE_CAST(x) (XED_STATIC_CAST(xed_uint8_t,x)) + +//////////////////////////////////////////////////////////////////////////// +// used for defining bit-field widths +// Microsoft's compiler treats enumerations as signed and if you pack +// the bit-field with values, when you assign it to a full-width enumeration, +// you get junk-- a big negative number. This compensates for cases that I've +// encountered +#if defined(__GNUC__) +# define XED_BIT_FIELD_PSEUDO_WIDTH4 4 +# define XED_BIT_FIELD_PSEUDO_WIDTH8 8 +#else +# define XED_BIT_FIELD_PSEUDO_WIDTH4 8 +# define XED_BIT_FIELD_PSEUDO_WIDTH8 16 +#endif + + +#endif + + + + + + + + + diff --git a/third_party/xed-intel64/include/xed-common-hdrs.h b/third_party/xed-intel64/include/xed-common-hdrs.h new file mode 100644 index 0000000..5847f79 --- /dev/null +++ b/third_party/xed-intel64/include/xed-common-hdrs.h @@ -0,0 +1,98 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-common-hdrs.h +/// + + + +#ifndef _XED_COMMON_HDRS_H_ +# define _XED_COMMON_HDRS_H_ + + + +#if defined(__FreeBSD__) +# define XED_BSD +#endif +#if defined(__linux__) +# define XED_LINUX +#endif +#if defined(_MSC_VER) +# define XED_WINDOWS +#endif +#if defined(__APPLE__) +# define XED_MAC +#endif + + +#if defined(XED_DLL) +// __declspec(dllexport) works with GNU GCC or MS compilers, but not ICC +// on linux + +# if defined(XED_WINDOWS) +# define XED_DLL_EXPORT __declspec(dllexport) +# define XED_DLL_IMPORT __declspec(dllimport) +# elif defined(XED_LINUX) || defined(XED_BSD) || defined(XED_MAC) +# define XED_DLL_EXPORT __attribute__((visibility("default"))) +# define XED_DLL_IMPORT +# else +# define XED_DLL_EXPORT +# define XED_DLL_IMPORT +# endif + +# if defined(XED_BUILD) + /* when building XED, we export symbols */ +# define XED_DLL_GLOBAL XED_DLL_EXPORT +# else + /* when building XED clients, we import symbols */ +# define XED_DLL_GLOBAL XED_DLL_IMPORT +# endif +#else +# define XED_DLL_EXPORT +# define XED_DLL_IMPORT +# define XED_DLL_GLOBAL +#endif + + +#if defined(XED_OMIT_ENCODER) + /* do not emit an encoder */ +#else +# define XED_ENCODER +#endif + +#if defined(XED_OMIT_DECODER) + /* do not emit a decoder */ +#else +# define XED_DECODER +#endif + +#endif + diff --git a/third_party/xed-intel64/include/xed-convert-table-init.h b/third_party/xed-intel64/include/xed-convert-table-init.h new file mode 100644 index 0000000..9a49219 --- /dev/null +++ b/third_party/xed-intel64/include/xed-convert-table-init.h @@ -0,0 +1,50 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-convert-table-init.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_CONVERT_TABLE_INIT_H_) +# define _XED_CONVERT_TABLE_INIT_H_ +#include "xed-internal-header.h" +typedef struct { + + const char** table_name; + + xed_operand_enum_t opnd; + + unsigned int limit; + +} xed_convert_table_t; +extern xed_convert_table_t xed_convert_table[XED_OPERAND_CONVERT_LAST]; +#endif diff --git a/third_party/xed-intel64/include/xed-cpuid-bit-enum.h b/third_party/xed-intel64/include/xed-cpuid-bit-enum.h new file mode 100644 index 0000000..1f81aa9 --- /dev/null +++ b/third_party/xed-intel64/include/xed-cpuid-bit-enum.h @@ -0,0 +1,115 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-cpuid-bit-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_CPUID_BIT_ENUM_H_) +# define _XED_CPUID_BIT_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_CPUID_BIT_INVALID, + XED_CPUID_BIT_ADOXADCX, + XED_CPUID_BIT_AES, + XED_CPUID_BIT_AVX, + XED_CPUID_BIT_AVX2, + XED_CPUID_BIT_AVX512BW, + XED_CPUID_BIT_AVX512CD, + XED_CPUID_BIT_AVX512DQ, + XED_CPUID_BIT_AVX512ER, + XED_CPUID_BIT_AVX512F, + XED_CPUID_BIT_AVX512IFMA, + XED_CPUID_BIT_AVX512PF, + XED_CPUID_BIT_AVX512VBMI, + XED_CPUID_BIT_AVX512VL, + XED_CPUID_BIT_BMI1, + XED_CPUID_BIT_BMI2, + XED_CPUID_BIT_CLFLUSH, + XED_CPUID_BIT_CLFLUSHOPT, + XED_CPUID_BIT_CLWB, + XED_CPUID_BIT_CMPXCHG16B, + XED_CPUID_BIT_F16C, + XED_CPUID_BIT_FMA, + XED_CPUID_BIT_FXSAVE, + XED_CPUID_BIT_INTEL64, + XED_CPUID_BIT_INTELPT, + XED_CPUID_BIT_INVPCID, + XED_CPUID_BIT_LAHF, + XED_CPUID_BIT_LZCNT, + XED_CPUID_BIT_MOVEBE, + XED_CPUID_BIT_MPX, + XED_CPUID_BIT_OSXSAVE, + XED_CPUID_BIT_PCLMULQDQ, + XED_CPUID_BIT_PCOMMIT, + XED_CPUID_BIT_POPCNT, + XED_CPUID_BIT_PREFETCHW, + XED_CPUID_BIT_PREFETCHWT1, + XED_CPUID_BIT_RDRAND, + XED_CPUID_BIT_RDSEED, + XED_CPUID_BIT_RDTSCP, + XED_CPUID_BIT_RDWRFSGS, + XED_CPUID_BIT_RTM, + XED_CPUID_BIT_SGX, + XED_CPUID_BIT_SHA, + XED_CPUID_BIT_SMAP, + XED_CPUID_BIT_SMX, + XED_CPUID_BIT_SSE, + XED_CPUID_BIT_SSE2, + XED_CPUID_BIT_SSE3, + XED_CPUID_BIT_SSE4, + XED_CPUID_BIT_SSE42, + XED_CPUID_BIT_SSSE3, + XED_CPUID_BIT_VMX, + XED_CPUID_BIT_XSAVE, + XED_CPUID_BIT_XSAVEC, + XED_CPUID_BIT_XSAVEOPT, + XED_CPUID_BIT_XSAVES, + XED_CPUID_BIT_LAST +} xed_cpuid_bit_enum_t; + +/// This converts strings to #xed_cpuid_bit_enum_t types. +/// @param s A C-string. +/// @return #xed_cpuid_bit_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_cpuid_bit_enum_t str2xed_cpuid_bit_enum_t(const char* s); +/// This converts strings to #xed_cpuid_bit_enum_t types. +/// @param p An enumeration element of type xed_cpuid_bit_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_cpuid_bit_enum_t2str(const xed_cpuid_bit_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_cpuid_bit_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_cpuid_bit_enum_t xed_cpuid_bit_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-cpuid-rec.h b/third_party/xed-intel64/include/xed-cpuid-rec.h new file mode 100644 index 0000000..6845266 --- /dev/null +++ b/third_party/xed-intel64/include/xed-cpuid-rec.h @@ -0,0 +1,69 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#ifndef _XED_CPUID_REC_H_ +# define _XED_CPUID_REC_H_ +#include "../../../third_party/xed-intel64/include/xed-cpuid-bit-enum.h" +#include "../../../third_party/xed-intel64/include/xed-isa-set-enum.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +typedef struct { + xed_uint32_t leaf; // cpuid leaf + xed_uint32_t subleaf; // cpuid subleaf + xed_uint32_t bit; // the bit number for the feature + xed_reg_enum_t reg; // the register containing the bit (EAX,EBX,ECX,EDX) +} xed_cpuid_rec_t; + +#define XED_MAX_CPUID_BITS_PER_ISA_SET (4) + +/// Returns the name of the i'th cpuid bit associated with this isa-set. +/// Call this repeatedly, with 0 <= i < +/// XED_MAX_CPUID_BITS_PER_ISA_SET. Give up when i == +/// XED_MAX_CPUID_BITS_PER_ISA_SET or the return value is +/// XED_CPUID_BIT_INVALID. +XED_DLL_EXPORT +xed_cpuid_bit_enum_t +xed_get_cpuid_bit_for_isa_set(xed_isa_set_enum_t isaset, + xed_uint_t i); + +/// This provides the details of the CPUID bit specification, if the +/// enumeration value is not sufficient. Returns 1 on success and fills in +/// the structure pointed to by p. Returns 0 on failure. +XED_DLL_EXPORT +xed_int_t +xed_get_cpuid_rec(xed_cpuid_bit_enum_t cpuid_bit, + xed_cpuid_rec_t* p); + +#endif + diff --git a/third_party/xed-intel64/include/xed-decode.h b/third_party/xed-intel64/include/xed-decode.h new file mode 100644 index 0000000..8f17882 --- /dev/null +++ b/third_party/xed-intel64/include/xed-decode.h @@ -0,0 +1,71 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-decode.h + + +#ifndef _XED_DECODE_H_ +# define _XED_DECODE_H_ + +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-error-enum.h" + +/// This is the main interface to the decoder. +/// @param xedd the decoded instruction of type #xed_decoded_inst_t . Mode/state sent in via xedd; See the #xed_state_t +/// @param itext the pointer to the array of instruction text bytes +/// @param bytes the length of the itext input array. 1 to 15 bytes, anything more is ignored. +/// @return #xed_error_enum_t indiciating success (#XED_ERROR_NONE) or failure. Note failure can be due to not +/// enough bytes in the input array. +/// +/// The maximum instruction is 15B and XED will tell you how long the +/// actual instruction is via an API function call +/// xed_decoded_inst_get_length(). However, it is not always safe or +/// advisable for XED to read 15 bytes if the decode location is at the +/// boundary of some sort of protection limit. For example, if one is +/// decoding near the end of a page and the XED user does not want to cause +/// extra page faults, one might send in the number of bytes that would +/// stop at the page boundary. In this case, XED might not be able to +/// decode the instruction and would return an error. The XED user would +/// then have to decide if it was safe to touch the next page and try again +/// to decode with more bytes. Also sometimes the user process does not +/// have read access to the next page and this allows the user to prevent +/// XED from causing process termination by limiting the memory range that +/// XED will access. +/// +/// @ingroup DEC +XED_DLL_EXPORT xed_error_enum_t +xed_decode(xed_decoded_inst_t* xedd, + const xed_uint8_t* itext, + const unsigned int bytes); + + +#endif + diff --git a/third_party/xed-intel64/include/xed-decoded-inst-api.h b/third_party/xed-intel64/include/xed-decoded-inst-api.h new file mode 100644 index 0000000..54dc35d --- /dev/null +++ b/third_party/xed-intel64/include/xed-decoded-inst-api.h @@ -0,0 +1,667 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-decoded-inst-api.h +/// + +#if !defined(_XED_DECODED_INST_API_H_) +# define _XED_DECODED_INST_API_H_ + +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-operand-accessors.h" +#include "../../../third_party/xed-intel64/include/xed-operand-values-interface.h" +#include "../../../third_party/xed-intel64/include/xed-print-info.h" +#include "../../../third_party/xed-intel64/include/xed-state.h" + +/////////////////////////////////////////////////////// +/// API +/////////////////////////////////////////////////////// + +/// @name xed_decoded_inst_t High-level accessors +//@{ +/// @ingroup DEC +/// Return true if the instruction is valid +static XED_INLINE xed_bool_t +xed_decoded_inst_valid(const xed_decoded_inst_t* p ) { + return XED_STATIC_CAST(xed_bool_t,(p->_inst != 0)); +} +/// @ingroup DEC +/// Return the #xed_inst_t structure for this instruction. This is the +/// route to the basic operands form information. +static XED_INLINE const xed_inst_t* +xed_decoded_inst_inst( const xed_decoded_inst_t* p) { + return p->_inst; +} + + +/// @ingroup DEC +/// Return the instruction #xed_category_enum_t enumeration +static XED_INLINE xed_category_enum_t +xed_decoded_inst_get_category(const xed_decoded_inst_t* p) { + xed_assert(p->_inst != 0); + return xed_inst_category(p->_inst); +} +/// @ingroup DEC +/// Return the instruction #xed_extension_enum_t enumeration +static XED_INLINE xed_extension_enum_t +xed_decoded_inst_get_extension( const xed_decoded_inst_t* p) { + xed_assert(p->_inst != 0); + return xed_inst_extension(p->_inst); +} +/// @ingroup DEC +/// Return the instruction #xed_isa_set_enum_t enumeration +static XED_INLINE xed_isa_set_enum_t +xed_decoded_inst_get_isa_set(xed_decoded_inst_t const* const p) { + xed_assert(p->_inst != 0); + return xed_inst_isa_set(p->_inst); +} +/// @ingroup DEC +/// Return the instruction #xed_iclass_enum_t enumeration. +static XED_INLINE xed_iclass_enum_t +xed_decoded_inst_get_iclass( const xed_decoded_inst_t* p){ + xed_assert(p->_inst != 0); + return xed_inst_iclass(p->_inst); +} + +/// @name xed_decoded_inst_t Attirbutes and properties +//@{ +/// @ingroup DEC +/// Returns 1 if the attribute is defined for this instruction. +XED_DLL_EXPORT xed_uint32_t +xed_decoded_inst_get_attribute(const xed_decoded_inst_t* p, + xed_attribute_enum_t attr); + +/// @ingroup DEC +/// Returns the attribute bitvector +XED_DLL_EXPORT xed_attributes_t +xed_decoded_inst_get_attributes(const xed_decoded_inst_t* p); +//@} + +/// @ingroup DEC +/// Returns 1 if the instruction is xacquire. +XED_DLL_EXPORT xed_uint32_t +xed_decoded_inst_is_xacquire(const xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Returns 1 if the instruction is xrelease. +XED_DLL_EXPORT xed_uint32_t +xed_decoded_inst_is_xrelease(const xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Returns 1 if the instruction has mpx prefix. +XED_DLL_EXPORT xed_uint32_t +xed_decoded_inst_has_mpx_prefix(const xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Returns the modrm byte +XED_DLL_EXPORT xed_uint8_t +xed_decoded_inst_get_modrm(const xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Returns 1 iff the instruction uses destination-masking. This is 0 for +/// blend operations that use their mask field as a control. +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_masked_vector_operation(xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Returns 128, 256 or 512 for operations in the VEX, EVEX (or XOP) +/// encoding space and returns 0 for (most) nonvector operations. +/// This usually the content of the VEX.L or EVEX.LL field, reinterpreted. +/// Some GPR instructions (like the BMI1/BMI2) are encoded in the VEX space +/// and return non-zero values from this API. +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_vector_length_bits(xed_decoded_inst_t const* const p); + +/// @ingroup DEC +/// Returns the number of legacy prefixes. +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_nprefixes(xed_decoded_inst_t* p); + +//@} + + +/// @name xed_decoded_inst_t Operands +//@{ +/// @ingroup DEC +/// Obtain a constant pointer to the operands +static XED_INLINE const xed_operand_values_t* +xed_decoded_inst_operands_const(const xed_decoded_inst_t* p) { + return p; +} +/// @ingroup DEC +/// Obtain a non-constant pointer to the operands +static XED_INLINE xed_operand_values_t* +xed_decoded_inst_operands(xed_decoded_inst_t* p) { + return p; +} + +/// Return the length in bits of the operand_index'th operand. +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_operand_length_bits(const xed_decoded_inst_t* p, + unsigned int operand_index); + + +/// Deprecated -- returns the length in bytes of the operand_index'th +/// operand. Use #xed_decoded_inst_operand_length_bits() instead. +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_operand_length(const xed_decoded_inst_t* p, + unsigned int operand_index); + + +/// Return the number of operands +/// @ingroup DEC +static XED_INLINE unsigned int +xed_decoded_inst_noperands(const xed_decoded_inst_t* p) { + unsigned int noperands = xed_inst_noperands(xed_decoded_inst_inst(p)); + return noperands; +} + + +/// Return the number of element in the operand (for SSE and AVX operands) +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_operand_elements(const xed_decoded_inst_t* p, + unsigned int operand_index); + +/// Return the size of an element in bits (for SSE and AVX operands) +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_operand_element_size_bits(const xed_decoded_inst_t* p, + unsigned int operand_index); + +/// Return the type of an element of type #xed_operand_element_type_enum_t +/// (for SSE and AVX operands) +/// @ingroup DEC +XED_DLL_EXPORT xed_operand_element_type_enum_t +xed_decoded_inst_operand_element_type(const xed_decoded_inst_t* p, + unsigned int operand_index); + +/// Interpret the operand action in light of AVX512 masking and +/// zeroing/merging. If masking and merging are used together, the dest +/// operand may also be read. If masking and merging are used together, +/// the elemnents of dest operand register may be conditionally written (so +/// that input values live on in the output register). +/// @ingroup DEC +XED_DLL_EXPORT xed_operand_action_enum_t +xed_decoded_inst_operand_action(const xed_decoded_inst_t* p, + unsigned int operand_index); + +//@} + +/// @name xed_decoded_inst_t AVX512 Masking +//@{ +/// Returns true if the instruction uses write-masking +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_masking(const xed_decoded_inst_t* p); + +/// Returns true if the instruction uses write-masking with merging +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_merging(const xed_decoded_inst_t* p); + +/// Returns true if the instruction uses write-masking with zeroing +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_zeroing(const xed_decoded_inst_t* p); +//@} + +/// @name xed_decoded_inst_t Initialization +//@{ +/// @ingroup DEC +/// Zero the decode structure, but set the machine state/mode +/// information. Re-initializes all operands. +XED_DLL_EXPORT void +xed_decoded_inst_zero_set_mode(xed_decoded_inst_t* p, + const xed_state_t* dstate); + +/// @ingroup DEC +/// Zero the decode structure, but preserve the existing machine state/mode +/// information. Re-initializes all operands. +XED_DLL_EXPORT void xed_decoded_inst_zero_keep_mode(xed_decoded_inst_t* p); + + +/// @ingroup DEC +/// Zero the decode structure completely. Re-initializes all operands. +XED_DLL_EXPORT void xed_decoded_inst_zero(xed_decoded_inst_t* p); + +/// @ingroup DEC +/// Set the machine mode and stack addressing width directly. This is NOT a +/// full initialization; Call #xed_decoded_inst_zero() before using this if +/// you want a clean slate. +static XED_INLINE void +xed_decoded_inst_set_mode(xed_decoded_inst_t* p, + xed_machine_mode_enum_t mmode, + xed_address_width_enum_t stack_addr_width) +{ + xed_state_t dstate; + dstate.mmode = mmode; + dstate.stack_addr_width = stack_addr_width; + xed_operand_values_set_mode(p, &dstate); +} + + + +/// @ingroup DEC +/// Zero the decode structure, but copy the existing machine state/mode +/// information from the supplied operands pointer. Same as +/// #xed_decoded_inst_zero_keep_mode. +XED_DLL_EXPORT void +xed_decoded_inst_zero_keep_mode_from_operands( + xed_decoded_inst_t* p, + const xed_operand_values_t* operands); + +/// @name xed_decoded_inst_t Length +//@{ +/// @ingroup DEC +/// Return the length of the decoded instruction in bytes. +static XED_INLINE xed_uint_t +xed_decoded_inst_get_length(const xed_decoded_inst_t* p) { + return p->_decoded_length; +} + +//@} + + +/// @name xed_decoded_inst_t get Byte +//@{ +/// @ingroup DEC +/// Read itext byte. +static XED_INLINE xed_uint8_t +xed_decoded_inst_get_byte(const xed_decoded_inst_t* p, xed_uint_t byte_index) +{ + /// Read a whole byte from the normal input bytes. + xed_uint8_t out = p->_byte_array._dec[byte_index]; + return out; +} + +//@} + +/// @name Modes +//@{ +/// @ingroup DEC +/// Returns 16/32/64 indicating the machine mode with in bits. This is +/// derived from the input mode information. +static XED_INLINE xed_uint_t +xed_decoded_inst_get_machine_mode_bits(const xed_decoded_inst_t* p) { + xed_uint8_t mode = xed3_operand_get_mode(p); + if (mode == 2) return 64; + if (mode == 1) return 32; + return 16; +} +/// @ingroup DEC +/// Returns 16/32/64 indicating the stack addressing mode with in +/// bits. This is derived from the input mode information. +static XED_INLINE xed_uint_t +xed_decoded_inst_get_stack_address_mode_bits(const xed_decoded_inst_t* p) { + xed_uint8_t smode = xed3_operand_get_smode(p); + if (smode == 2) return 64; + if (smode == 1) return 32; + return 16; +} + +/// Returns the operand width in bits: 8/16/32/64. This is different than +/// the #xed_operand_values_get_effective_operand_width() which only +/// returns 16/32/64. This factors in the BYTEOP attribute when computing +/// its return value. This is a convenience function. +/// @ingroup DEC +XED_DLL_EXPORT xed_uint32_t +xed_decoded_inst_get_operand_width(const xed_decoded_inst_t* p); + +/// Return the user-specified #xed_chip_enum_t chip name, or +/// XED_CHIP_INVALID if not set. +/// @ingroup DEC +static XED_INLINE xed_chip_enum_t +xed_decoded_inst_get_input_chip(const xed_decoded_inst_t* p) { + return xed3_operand_get_chip(p); +} + +/// Set a user-specified #xed_chip_enum_t chip name for restricting decode +/// @ingroup DEC +static XED_INLINE void +xed_decoded_inst_set_input_chip(xed_decoded_inst_t* p, + xed_chip_enum_t chip) { + xed3_operand_set_chip(p,chip); +} + + +/// Indicate if this decoded instruction is valid for the specified +/// #xed_chip_enum_t chip +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_valid_for_chip(xed_decoded_inst_t const* const p, + xed_chip_enum_t chip); + +//@} + + + + +/// @name IFORM handling +//@{ + +/// @ingroup DEC +/// Return the instruction iform enum of type #xed_iform_enum_t . +static XED_INLINE xed_iform_enum_t +xed_decoded_inst_get_iform_enum(const xed_decoded_inst_t* p) { + xed_assert(p->_inst != 0); + return xed_inst_iform_enum(p->_inst); +} + +/// @ingroup DEC +/// Return the instruction zero-based iform number based on masking the +/// corresponding #xed_iform_enum_t. This value is suitable for +/// dispatching. The maximum value for a particular iclass is provided by +/// #xed_iform_max_per_iclass() . +static XED_INLINE unsigned int +xed_decoded_inst_get_iform_enum_dispatch(const xed_decoded_inst_t* p) { + xed_assert(p->_inst != 0); + return xed_inst_iform_enum(p->_inst) - + xed_iform_first_per_iclass(xed_inst_iclass(p->_inst)); +} +//@} + + + + +/// @name xed_decoded_inst_t Printers +//@{ +/// @ingroup PRINT +/// Print out all the information about the decoded instruction to the +/// buffer buf whose length is maximally buflen. This is for debugging. +XED_DLL_EXPORT void +xed_decoded_inst_dump(const xed_decoded_inst_t* p, char* buf, int buflen); + + + +/// @ingroup PRINT +/// Print the instruction information in a verbose format. +/// This is for debugging. +/// @param p a #xed_decoded_inst_t for a decoded instruction +/// @param buf a buffer to write the disassembly in to. +/// @param buflen maximum length of the disassembly buffer +/// @param runtime_address the address of the instruction being disassembled. If zero, the offset is printed for relative branches. If nonzero, XED attempts to print the target address for relative branches. +/// @return Returns 0 if the disassembly fails, 1 otherwise. +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_dump_xed_format(const xed_decoded_inst_t* p, + char* buf, + int buflen, + xed_uint64_t runtime_address) ; + + +/// Disassemble the decoded instruction using the specified syntax. +/// The output buffer must be at least 25 bytes long. Returns true if +/// disassembly proceeded without errors. +/// @param syntax a #xed_syntax_enum_t the specifies the disassembly format +/// @param xedd a #xed_decoded_inst_t for a decoded instruction +/// @param out_buffer a buffer to write the disassembly in to. +/// @param buffer_len maximum length of the disassembly buffer +/// @param runtime_instruction_address the address of the instruction being disassembled. If zero, the offset is printed for relative branches. If nonzero, XED attempts to print the target address for relative branches. +/// @param context A void* used only for the call back routine for symbolic disassembly if one is provided. Can be zero. +/// @param symbolic_callback A function pointer for obtaining symbolic disassembly. Can be zero. +/// @return Returns 0 if the disassembly fails, 1 otherwise. +///@ingroup PRINT +XED_DLL_EXPORT xed_bool_t +xed_format_context(xed_syntax_enum_t syntax, + const xed_decoded_inst_t* xedd, + char* out_buffer, + int buffer_len, + xed_uint64_t runtime_instruction_address, + void* context, + xed_disassembly_callback_fn_t symbolic_callback); + + +/// @ingroup PRINT +/// Disassemble the instruction information to a buffer. See the +/// #xed_print_info_t for the required public fields of the argument. +/// This is the preferred method of doing disassembly. +/// The output buffer must be at least 25 bytes long. +/// @param pi a #xed_print_info_t +/// @return Returns 0 if the disassembly fails, 1 otherwise. +XED_DLL_EXPORT xed_bool_t +xed_format_generic(xed_print_info_t* pi); + +//@} + +/// @name xed_decoded_inst_t Operand Field Details +//@{ +/// @ingroup DEC +XED_DLL_EXPORT xed_reg_enum_t +xed_decoded_inst_get_seg_reg(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_reg_enum_t +xed_decoded_inst_get_base_reg(const xed_decoded_inst_t* p, + unsigned int mem_idx); +XED_DLL_EXPORT xed_reg_enum_t +xed_decoded_inst_get_index_reg(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_scale(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_int64_t +xed_decoded_inst_get_memory_displacement(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +/// Result in BYTES +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_memory_displacement_width(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +/// Result in BITS +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_memory_displacement_width_bits(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_int32_t +xed_decoded_inst_get_branch_displacement(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Result in BYTES +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_branch_displacement_width(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Result in BITS +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_branch_displacement_width_bits( + const xed_decoded_inst_t* p); +/// @ingroup DEC +XED_DLL_EXPORT xed_uint64_t +xed_decoded_inst_get_unsigned_immediate(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Return true if the first immediate (IMM0) is signed +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_immediate_is_signed(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Return the immediate width in BYTES. +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_immediate_width(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Return the immediate width in BITS. +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_get_immediate_width_bits(const xed_decoded_inst_t* p); +/// @ingroup DEC +XED_DLL_EXPORT xed_int32_t +xed_decoded_inst_get_signed_immediate(const xed_decoded_inst_t* p); +/// @ingroup DEC +/// Return the second immediate. +static XED_INLINE xed_uint8_t +xed_decoded_inst_get_second_immediate(const xed_decoded_inst_t* p) { + return xed3_operand_get_uimm1(p); +} + +/// @ingroup DEC +/// Return the specified register operand. The specifier is of type +/// #xed_operand_enum_t . +XED_DLL_EXPORT xed_reg_enum_t +xed_decoded_inst_get_reg(const xed_decoded_inst_t* p, + xed_operand_enum_t reg_operand); + + +/// See the comment on xed_decoded_inst_uses_rflags(). This can return +/// 0 if the flags are really not used by this instruction. +/// @ingroup DEC +XED_DLL_EXPORT const xed_simple_flag_t* +xed_decoded_inst_get_rflags_info( const xed_decoded_inst_t* p ); + +/// This returns 1 if the flags are read or written. This will return 0 +/// otherwise. This will return 0 if the flags are really not used by this +/// instruction. For some shifts/rotates, XED puts a flags operand in the +/// operand array before it knows if the flags are used because of +/// mode-dependent masking effects on the immediate. +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_uses_rflags(const xed_decoded_inst_t* p); + +/// @ingroup DEC +XED_DLL_EXPORT xed_uint_t +xed_decoded_inst_number_of_memory_operands(const xed_decoded_inst_t* p); +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_mem_read(const xed_decoded_inst_t* p, unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_mem_written(const xed_decoded_inst_t* p, unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_mem_written_only(const xed_decoded_inst_t* p, + unsigned int mem_idx); +/// @ingroup DEC +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_conditionally_writes_registers(const xed_decoded_inst_t* p); +/// returns bytes +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_get_memory_operand_length(const xed_decoded_inst_t* p, + unsigned int memop_idx); + +/// Returns the addressing width in bits (16,32,64) for MEM0 (memop_idx==0) +/// or MEM1 (memop_idx==1). This factors in things like whether or not the +/// reference is an implicit stack push/pop reference, the machine mode and +// 67 prefixes if present. +/// @ingroup DEC +XED_DLL_EXPORT unsigned int +xed_decoded_inst_get_memop_address_width(const xed_decoded_inst_t* p, + xed_uint_t memop_idx); + + + +/// @ingroup DEC +/// Returns true if the instruction is a prefetch +XED_DLL_EXPORT xed_bool_t +xed_decoded_inst_is_prefetch(const xed_decoded_inst_t* p); +//@} + + +/// @name xed_decoded_inst_t Modification +//@{ +// Modifying decoded instructions before re-encoding +/// @ingroup DEC +XED_DLL_EXPORT void +xed_decoded_inst_set_scale(xed_decoded_inst_t* p, xed_uint_t scale); +/// @ingroup DEC +/// Set the memory displacement using a BYTE length +XED_DLL_EXPORT void +xed_decoded_inst_set_memory_displacement(xed_decoded_inst_t* p, + xed_int64_t disp, + xed_uint_t length_bytes); +/// @ingroup DEC +/// Set the branch displacement using a BYTE length +XED_DLL_EXPORT void +xed_decoded_inst_set_branch_displacement(xed_decoded_inst_t* p, + xed_int32_t disp, + xed_uint_t length_bytes); +/// @ingroup DEC +/// Set the signed immediate a BYTE length +XED_DLL_EXPORT void +xed_decoded_inst_set_immediate_signed(xed_decoded_inst_t* p, + xed_int32_t x, + xed_uint_t length_bytes); +/// @ingroup DEC +/// Set the unsigned immediate a BYTE length +XED_DLL_EXPORT void +xed_decoded_inst_set_immediate_unsigned(xed_decoded_inst_t* p, + xed_uint64_t x, + xed_uint_t length_bytes); + + +/// @ingroup DEC +/// Set the memory displacement a BITS length +XED_DLL_EXPORT void +xed_decoded_inst_set_memory_displacement_bits(xed_decoded_inst_t* p, + xed_int64_t disp, + xed_uint_t length_bits); +/// @ingroup DEC +/// Set the branch displacement a BITS length +XED_DLL_EXPORT void +xed_decoded_inst_set_branch_displacement_bits(xed_decoded_inst_t* p, + xed_int32_t disp, + xed_uint_t length_bits); +/// @ingroup DEC +/// Set the signed immediate a BITS length +XED_DLL_EXPORT void +xed_decoded_inst_set_immediate_signed_bits(xed_decoded_inst_t* p, + xed_int32_t x, + xed_uint_t length_bits); +/// @ingroup DEC +/// Set the unsigned immediate a BITS length +XED_DLL_EXPORT void +xed_decoded_inst_set_immediate_unsigned_bits(xed_decoded_inst_t* p, + xed_uint64_t x, + xed_uint_t length_bits); + +//@} + +/// @name xed_decoded_inst_t User Data Field +//@{ +/// @ingroup DEC +/// Return a user data field for arbitrary use by the user after decoding. +static XED_INLINE xed_uint64_t +xed_decoded_inst_get_user_data(xed_decoded_inst_t* p) { + return p->u.user_data; +} +/// @ingroup DEC +/// Modify the user data field. +static XED_INLINE void +xed_decoded_inst_set_user_data(xed_decoded_inst_t* p, + xed_uint64_t new_value) { + p->u.user_data = new_value; +} + + + + +//@} +#endif + diff --git a/third_party/xed-intel64/include/xed-decoded-inst.h b/third_party/xed-intel64/include/xed-decoded-inst.h new file mode 100644 index 0000000..3cc9fb4 --- /dev/null +++ b/third_party/xed-intel64/include/xed-decoded-inst.h @@ -0,0 +1,105 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-decoded-inst.h +/// + +#if !defined(_XED_DECODER_STATE_H_) +# define _XED_DECODER_STATE_H_ +#include "../../../third_party/xed-intel64/include/xed-common-defs.h" +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-flags.h" +#include "../../../third_party/xed-intel64/include/xed-inst.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" +#include "../../../third_party/xed-intel64/include/xed-util.h" +#if defined(XED_ENCODER) +# include "../../../third_party/xed-intel64/include/xed-encoder-gen-defs.h" //generated +#endif +#include "../../../third_party/xed-intel64/include/xed-chip-enum.h" //generated +#include "../../../third_party/xed-intel64/include/xed-operand-element-type-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-operand-storage.h" // a generated file + + +struct xed_encoder_vars_s; +struct xed_decoder_vars_s; +/// @ingroup DEC +/// The main container for instructions. After decode, it holds an array of +/// operands with derived information from decode and also valid +/// #xed_inst_t pointer which describes the operand templates and the +/// operand order. See @ref DEC for API documentation. +typedef struct xed_decoded_inst_s { + /// The _operands are storage for information discovered during + /// decoding. They are also used by encode. The accessors for these + /// operands all have the form xed3_operand_{get,set}_*(). They should + /// be considered internal and subject to change over time. It is + /// preferred that you use xed_decoded_inst_*() or the + /// xed_operand_values_*() functions when available. + xed_operand_storage_t _operands; + +#if defined(XED_ENCODER) + /// Used for encode operand ordering. Not set by decode. + xed_uint8_t _operand_order[XED_ENCODE_ORDER_MAX_OPERANDS]; + /// Length of the _operand_order[] array. + xed_uint8_t _n_operand_order; +#endif + xed_uint8_t _decoded_length; + + /// when we decode an instruction, we set the _inst and get the + /// properites of that instruction here. This also points to the + /// operands template array. + const xed_inst_t* _inst; + + // decoder does not change it, encoder does + union { + xed_uint8_t* _enc; + const xed_uint8_t* _dec; + } _byte_array; + + // The ev field is stack allocated by xed_encode(). It is per-encode + // transitory data. + union { + /* user_data is available as a user data storage field after + * decoding. It does not live across re-encodes or re-decodes. */ + xed_uint64_t user_data; +#if defined(XED_ENCODER) + struct xed_encoder_vars_s* ev; +#endif + } u; + +} xed_decoded_inst_t; + +typedef xed_decoded_inst_t xed_operand_values_t; + + +//@} +#endif + diff --git a/third_party/xed-intel64/include/xed-disas.h b/third_party/xed-intel64/include/xed-disas.h new file mode 100644 index 0000000..8d65323 --- /dev/null +++ b/third_party/xed-intel64/include/xed-disas.h @@ -0,0 +1,66 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-disas.h +/// + +#if !defined(_XED_DISAS_H_) +# define _XED_DISAS_H_ + +#include "../../../third_party/xed-intel64/include/xed-types.h" + +/// @ingroup PRINT +/// A #xed_disassembly_callback_fn_t takes an address, a pointer to a +/// symbol buffer of buffer_length bytes, and a pointer to an offset. The +/// function fills in the symbol_buffer and sets the offset to the desired +/// offset for that symbol. If the function succeeds, it returns 1. +// The call back should return 0 if the buffer is not long enough to +// include the null termination.If no symbolic information is +// located, the function returns zero. +/// @param address The input address for which we want symbolic name and offset +/// @param symbol_buffer A buffer to hold the symbol name. The callback function should fill this in and terminate +/// with a null byte. +/// @param buffer_length The maximum length of the symbol_buffer including then null +/// @param offset A pointer to a xed_uint64_t to hold the offset from the provided symbol. +/// @param context This void* pointer passed to the disassembler's new interface so that the caller can identify +/// the proper context against which to resolve the symbols. +/// The disassembler passes this value to +/// the callback. The legacy formatters +/// that do not have context will pass zero for this parameter. +/// @return 0 on failure, 1 on success. +typedef int (*xed_disassembly_callback_fn_t)( + xed_uint64_t address, + char* symbol_buffer, + xed_uint32_t buffer_length, + xed_uint64_t* offset, + void* context); + +#endif diff --git a/third_party/xed-intel64/include/xed-encode.h b/third_party/xed-intel64/include/xed-encode.h new file mode 100644 index 0000000..75da98e --- /dev/null +++ b/third_party/xed-intel64/include/xed-encode.h @@ -0,0 +1,301 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-encode.h + + +#ifndef _XED_ENCODE_H_ +# define _XED_ENCODE_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-encoder-gen-defs.h" //generated +#include "../../../third_party/xed-intel64/include/xed-encoder-iforms.h" //generated +#include "../../../third_party/xed-intel64/include/xed-error-enum.h" +#include "../../../third_party/xed-intel64/include/xed-operand-values-interface.h" +#include "../../../third_party/xed-intel64/include/xed-operand-width-enum.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +// establish a type equivalence for the xed_encoder_request_t and the corresponding xed_decoded_inst_t. + +/// @ingroup ENC +typedef struct xed_decoded_inst_s xed_encoder_request_s; +/// @ingroup ENC +typedef xed_decoded_inst_t xed_encoder_request_t; + + + +/// @ingroup ENC +XED_DLL_EXPORT xed_iclass_enum_t +xed_encoder_request_get_iclass( const xed_encoder_request_t* p); + +///////////////////////////////////////////////////////// +// set functions + +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_iclass( xed_encoder_request_t* p, + xed_iclass_enum_t iclass); + +/// @name Prefixes +//@{ +/// @ingroup ENC +/// For locked (atomic read-modify-write) memops requests. +XED_DLL_EXPORT void xed_encoder_request_set_lock(xed_encoder_request_t* p); +/// @ingroup ENC +/// for REPNE(F2) prefix on string ops +XED_DLL_EXPORT void xed_encoder_request_set_repne(xed_encoder_request_t* p); +/// @ingroup ENC +/// for REP(F3) prefix on string ops +XED_DLL_EXPORT void xed_encoder_request_set_rep(xed_encoder_request_t* p); +/// @ingroup ENC +/// clear the REP prefix indicator +XED_DLL_EXPORT void xed_encoder_request_clear_rep(xed_encoder_request_t* p); +//@} + +/// @name Primary Encode Functions +//@{ +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_effective_operand_width( xed_encoder_request_t* p, + xed_uint_t width_bits); +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_effective_address_size( xed_encoder_request_t* p, + xed_uint_t width_bits); +/*! @ingroup ENC + * + * Set the operands array element indexed by operand to the actual register + * name reg. + * + * @param[in] p xed_encoder_request_t + * @param[in] operand indicates which register operand storage field to use + * @param[in] reg the actual register represented (EAX, etc.) to store. + */ +XED_DLL_EXPORT void xed_encoder_request_set_reg(xed_encoder_request_t* p, + xed_operand_enum_t operand, + xed_reg_enum_t reg); +//@} + +/// @name Operand Order +//@{ +/*! @ingroup ENC + * Specify the name as the n'th operand in the operand order. + * + * The complication of this function is that the register operand names are + * specific to the position of the operand (REG0, REG1, REG2...). One can + * use this function for registers or one can use the + * xed_encoder_request_set_operand_name_reg() which takes integers instead + * of operand names. + * + * @param[in] p #xed_encoder_request_t + * @param[in] operand_index xed_uint_t representing n'th operand position + * @param[in] name #xed_operand_enum_t operand name. + */ +XED_DLL_EXPORT void +xed_encoder_request_set_operand_order(xed_encoder_request_t* p, + xed_uint_t operand_index, + xed_operand_enum_t name); + +/*! @ingroup ENC + * Retreive the name of the n'th operand in the operand order. + * + * @param[in] p #xed_encoder_request_t + * @param[in] operand_index xed_uint_t representing n'th operand position + * @return The #xed_operand_enum_t operand name. + */ +XED_DLL_EXPORT xed_operand_enum_t +xed_encoder_request_get_operand_order(xed_encoder_request_t* p, + xed_uint_t operand_index); + + +/// @ingroup ENC +/// Retreive the number of entries in the encoder operand order array +/// @return The number of entries in the encoder operand order array +static XED_INLINE xed_uint_t +xed_encoder_request_operand_order_entries(xed_encoder_request_t* p) +{ + return p->_n_operand_order; +} + +//@} + + +/// @name branches and far pointers +//@{ +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_relbr(xed_encoder_request_t* p); +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_branch_displacement(xed_encoder_request_t* p, + xed_int32_t brdisp, + xed_uint_t nbytes); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_ptr(xed_encoder_request_t* p); +//@} + + +/// @name Immediates +//@{ +/// @ingroup ENC +/// Set the uimm0 using a BYTE width. +XED_DLL_EXPORT void xed_encoder_request_set_uimm0(xed_encoder_request_t* p, + xed_uint64_t uimm, + xed_uint_t nbytes); +/// @ingroup ENC +/// Set the uimm0 using a BIT width. +XED_DLL_EXPORT void xed_encoder_request_set_uimm0_bits(xed_encoder_request_t* p, + xed_uint64_t uimm, + xed_uint_t nbits); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_uimm1(xed_encoder_request_t* p, + xed_uint8_t uimm); +/// @ingroup ENC +/// same storage as uimm0 +XED_DLL_EXPORT void xed_encoder_request_set_simm(xed_encoder_request_t* p, + xed_int32_t simm, + xed_uint_t nbytes); + +/// @name Memory +//@{ +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_memory_displacement(xed_encoder_request_t* p, + xed_int64_t memdisp, + xed_uint_t nbytes); + +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_agen(xed_encoder_request_t* p); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_mem0(xed_encoder_request_t* p); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_mem1(xed_encoder_request_t* p); +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_memory_operand_length(xed_encoder_request_t* p, + xed_uint_t nbytes); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_seg0(xed_encoder_request_t* p, + xed_reg_enum_t seg_reg); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_seg1(xed_encoder_request_t* p, + xed_reg_enum_t seg_reg); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_base0(xed_encoder_request_t* p, + xed_reg_enum_t base_reg); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_base1(xed_encoder_request_t* p, + xed_reg_enum_t base_reg) ; +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_set_index(xed_encoder_request_t* p, + xed_reg_enum_t index_reg); +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_set_scale(xed_encoder_request_t* p, + xed_uint_t scale); +//@} + +////////////////////////////////////////////// +/// @ingroup ENC +XED_DLL_EXPORT const xed_operand_values_t* +xed_encoder_request_operands_const(const xed_encoder_request_t* p); +/// @ingroup ENC +XED_DLL_EXPORT xed_operand_values_t* +xed_encoder_request_operands(xed_encoder_request_t* p); + +/// @name Initialization +//@{ +/*! @ingroup ENC + * clear the operand order array + * @param[in] p xed_encoder_request_t + */ +XED_DLL_EXPORT void +xed_encoder_request_zero_operand_order(xed_encoder_request_t* p); + +/// @ingroup ENC +XED_DLL_EXPORT void +xed_encoder_request_zero_set_mode(xed_encoder_request_t* p, + const xed_state_t* dstate); +/// @ingroup ENC +XED_DLL_EXPORT void xed_encoder_request_zero(xed_encoder_request_t* p) ; +//@} + +struct xed_decoded_inst_s; //fwd decl +/// @ingroup ENC +/// Converts an decoder request to a valid encoder request. +XED_DLL_EXPORT void +xed_encoder_request_init_from_decode(struct xed_decoded_inst_s* d); + +/// @name String Printing +//@{ +/// @ingroup ENC +XED_DLL_EXPORT void xed_encode_request_print(const xed_encoder_request_t* p, + char* buf, xed_uint_t buflen); +//@} + + + + +/// @name Encoding +//@{ +/// This is the main interface to the encoder. The array should be +/// at most 15 bytes long. The ilen parameter should indiciate +/// this length. If the array is too short, the encoder may fail to +/// encode the request. Failure is indicated by a return value of +/// type #xed_error_enum_t that is not equal to +/// #XED_ERROR_NONE. Otherwise, #XED_ERROR_NONE is returned and the +/// length of the encoded instruction is returned in olen. +/// +/// @param r encoder request description (#xed_encoder_request_t), includes mode info +/// @param array the encoded instruction bytes are stored here +/// @param ilen the input length of array. +/// @param olen the actual length of array used for encoding +/// @return success/failure as a #xed_error_enum_t +/// @ingroup ENC +XED_DLL_EXPORT xed_error_enum_t +xed_encode(xed_encoder_request_t* r, + xed_uint8_t* array, + const unsigned int ilen, + unsigned int* olen); + +/// This function will attempt to encode a NOP of exactly ilen +/// bytes. If such a NOP is not encodeable, then false will be returned. +/// +/// @param array the encoded instruction bytes are stored here +/// @param ilen the input length array. +/// @return success/failure as a #xed_error_enum_t +/// @ingroup ENC +XED_DLL_EXPORT xed_error_enum_t +xed_encode_nop(xed_uint8_t* array, + const unsigned int ilen); +//@} + +#endif diff --git a/third_party/xed-intel64/include/xed-encoder-gen-defs.h b/third_party/xed-intel64/include/xed-encoder-gen-defs.h new file mode 100644 index 0000000..ee158c2 --- /dev/null +++ b/third_party/xed-intel64/include/xed-encoder-gen-defs.h @@ -0,0 +1,46 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-encoder-gen-defs.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ENCODER_GEN_DEFS_H_) +# define _XED_ENCODER_GEN_DEFS_H_ +#define XED_ENCODE_ORDER_MAX_ENTRIES 32 +#define XED_ENCODE_ORDER_MAX_OPERANDS 5 +#define XED_ENCODE_MAX_FB_PATTERNS 102 +#define XED_ENCODE_MAX_EMIT_PATTERNS 169 +#define XED_ENCODE_FB_VALUES_TABLE_SIZE 5404 +#define XED_ENCODE_MAX_IFORMS 6374 +#define XED_ENC_GROUPS 463 +#endif diff --git a/third_party/xed-intel64/include/xed-encoder-hl.h b/third_party/xed-intel64/include/xed-encoder-hl.h new file mode 100644 index 0000000..517af67 --- /dev/null +++ b/third_party/xed-intel64/include/xed-encoder-hl.h @@ -0,0 +1,591 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#ifndef _XED_ENCODER_HL_H_ +# define _XED_ENCODER_HL_H_ +#include "../../../third_party/xed-intel64/include/xed-encode.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-reg-enum.h" +#include "../../../third_party/xed-intel64/include/xed-state.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +typedef struct { + xed_uint64_t displacement; + xed_uint32_t displacement_width; +} xed_enc_displacement_t; /* fixme bad name */ + +/// @name Memory Displacement +//@{ +/// @ingroup ENCHL +/// a memory displacement (not for branches) +static XED_INLINE +xed_enc_displacement_t xed_disp(xed_uint64_t displacement, + xed_uint32_t displacement_width ) { + xed_enc_displacement_t x; + x.displacement = displacement; + x.displacement_width = displacement_width; + return x; +} +//@} + +typedef struct { + xed_reg_enum_t seg; + xed_reg_enum_t base; + xed_reg_enum_t index; + xed_uint32_t scale; + xed_enc_displacement_t disp; +} xed_memop_t; + + +typedef enum { + XED_ENCODER_OPERAND_TYPE_INVALID, + XED_ENCODER_OPERAND_TYPE_BRDISP, + XED_ENCODER_OPERAND_TYPE_REG, + XED_ENCODER_OPERAND_TYPE_IMM0, + XED_ENCODER_OPERAND_TYPE_SIMM0, + XED_ENCODER_OPERAND_TYPE_IMM1, + XED_ENCODER_OPERAND_TYPE_MEM, + XED_ENCODER_OPERAND_TYPE_PTR, + + /* special for things with suppressed implicit memops */ + XED_ENCODER_OPERAND_TYPE_SEG0, + + /* special for things with suppressed implicit memops */ + XED_ENCODER_OPERAND_TYPE_SEG1, + + /* specific operand storage fields -- must supply a name */ + XED_ENCODER_OPERAND_TYPE_OTHER +} xed_encoder_operand_type_t; + +typedef struct { + xed_encoder_operand_type_t type; + union { + xed_reg_enum_t reg; + xed_int32_t brdisp; + xed_uint64_t imm0; + xed_uint8_t imm1; + struct { + xed_operand_enum_t operand_name; + xed_uint32_t value; + } s; + xed_memop_t mem; + } u; + xed_uint32_t width; +} xed_encoder_operand_t; + +/// @name Branch Displacement +//@{ +/// @ingroup ENCHL +/// a relative branch displacement operand +static XED_INLINE xed_encoder_operand_t xed_relbr(xed_int32_t brdisp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_BRDISP; + o.u.brdisp = brdisp; + o.width = width; + return o; +} +//@} + +/// @name Pointer Displacement +//@{ +/// @ingroup ENCHL +/// a relative displacement for a PTR operand -- the subsequent imm0 holds +///the 16b selector +static XED_INLINE xed_encoder_operand_t xed_ptr(xed_int32_t brdisp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_PTR; + o.u.brdisp = brdisp; + o.width = width; + return o; +} +//@} + +/// @name Register and Immmediate Operands +//@{ +/// @ingroup ENCHL +/// a register operand +static XED_INLINE xed_encoder_operand_t xed_reg(xed_reg_enum_t reg) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_REG; + o.u.reg = reg; + o.width = 0; + return o; +} + +/// @ingroup ENCHL +/// a first immediate operand (known as IMM0) +static XED_INLINE xed_encoder_operand_t xed_imm0(xed_uint64_t v, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_IMM0; + o.u.imm0 = v; + o.width = width; + return o; +} +/// @ingroup ENCHL +/// an 32b signed immediate operand +static XED_INLINE xed_encoder_operand_t xed_simm0(xed_int32_t v, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_SIMM0; + /* sign conversion: we store the int32 in an uint64. It gets sign + extended. Later we convert it to the right width for the + instruction. The maximum width of a signed immediate is currently + 32b. */ + o.u.imm0 = v; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// an second immediate operand (known as IMM1) +static XED_INLINE xed_encoder_operand_t xed_imm1(xed_uint8_t v) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_IMM1; + o.u.imm1 = v; + o.width = 8; + return o; +} + + +/// @ingroup ENCHL +/// an operand storage field name and value +static XED_INLINE xed_encoder_operand_t xed_other( + xed_operand_enum_t operand_name, + xed_int32_t value) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_OTHER; + o.u.s.operand_name = operand_name; + o.u.s.value = value; + o.width = 0; + return o; +} +//@} + + +//@} + +/// @name Memory and Segment-releated Operands +//@{ + +/// @ingroup ENCHL +/// seg reg override for implicit suppressed memory ops +static XED_INLINE xed_encoder_operand_t xed_seg0(xed_reg_enum_t seg0) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_SEG0; + o.u.reg = seg0; + return o; +} + +/// @ingroup ENCHL +/// seg reg override for implicit suppressed memory ops +static XED_INLINE xed_encoder_operand_t xed_seg1(xed_reg_enum_t seg1) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_SEG1; + o.u.reg = seg1; + return o; +} + +/// @ingroup ENCHL +/// memory operand - base only +static XED_INLINE xed_encoder_operand_t xed_mem_b(xed_reg_enum_t base, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = XED_REG_INVALID; + o.u.mem.index= XED_REG_INVALID; + o.u.mem.scale = 0; + o.u.mem.disp.displacement = 0; + o.u.mem.disp.displacement_width = 0; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// memory operand - base and displacement only +static XED_INLINE xed_encoder_operand_t xed_mem_bd(xed_reg_enum_t base, + xed_enc_displacement_t disp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = XED_REG_INVALID; + o.u.mem.index= XED_REG_INVALID; + o.u.mem.scale = 0; + o.u.mem.disp =disp; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// memory operand - base, index, scale, displacement +static XED_INLINE xed_encoder_operand_t xed_mem_bisd(xed_reg_enum_t base, + xed_reg_enum_t index, + xed_uint_t scale, + xed_enc_displacement_t disp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = XED_REG_INVALID; + o.u.mem.index= index; + o.u.mem.scale = scale; + o.u.mem.disp = disp; + o.width = width; + return o; +} + + +/// @ingroup ENCHL +/// memory operand - segment and base only +static XED_INLINE xed_encoder_operand_t xed_mem_gb(xed_reg_enum_t seg, + xed_reg_enum_t base, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = seg; + o.u.mem.index= XED_REG_INVALID; + o.u.mem.scale = 0; + o.u.mem.disp.displacement = 0; + o.u.mem.disp.displacement_width = 0; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// memory operand - segment, base and displacement only +static XED_INLINE xed_encoder_operand_t xed_mem_gbd(xed_reg_enum_t seg, + xed_reg_enum_t base, + xed_enc_displacement_t disp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = seg; + o.u.mem.index= XED_REG_INVALID; + o.u.mem.scale = 0; + o.u.mem.disp = disp; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// memory operand - segment and displacement only +static XED_INLINE xed_encoder_operand_t xed_mem_gd(xed_reg_enum_t seg, + xed_enc_displacement_t disp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = XED_REG_INVALID; + o.u.mem.seg = seg; + o.u.mem.index= XED_REG_INVALID; + o.u.mem.scale = 0; + o.u.mem.disp = disp; + o.width = width; + return o; +} + +/// @ingroup ENCHL +/// memory operand - segment, base, index, scale, and displacement +static XED_INLINE xed_encoder_operand_t xed_mem_gbisd(xed_reg_enum_t seg, + xed_reg_enum_t base, + xed_reg_enum_t index, + xed_uint_t scale, + xed_enc_displacement_t disp, + xed_uint_t width) { + xed_encoder_operand_t o; + o.type = XED_ENCODER_OPERAND_TYPE_MEM; + o.u.mem.base = base; + o.u.mem.seg = seg; + o.u.mem.index= index; + o.u.mem.scale = scale; + o.u.mem.disp = disp; + o.width = width; + return o; +} +//@} + +typedef union { + struct { + xed_uint32_t rep :1; + xed_uint32_t repne :1; + xed_uint32_t lock :1; + xed_uint32_t br_hint_taken :1; + xed_uint32_t br_hint_not_taken :1; + } s; + xed_uint32_t i; +} xed_encoder_prefixes_t; + +#define XED_ENCODER_OPERANDS_MAX 5 /* FIXME */ +typedef struct { + xed_state_t mode; + xed_iclass_enum_t iclass; /*FIXME: use iform instead? or allow either */ + xed_uint32_t effective_operand_width; + + /* the effective_address_width is only requires to be set for + * instructions * with implicit suppressed memops or memops with no + * base or index regs. When base or index regs are present, XED pick + * this up automatically from the register names. + + * FIXME: make effective_address_width required by all encodes for + * unifority. Add to xed_inst[0123]() APIs??? */ + xed_uint32_t effective_address_width; + + xed_encoder_prefixes_t prefixes; + xed_uint32_t noperands; + xed_encoder_operand_t operands[XED_ENCODER_OPERANDS_MAX]; +} xed_encoder_instruction_t; + +/// @name Instruction Properties and prefixes +//@{ +/// @ingroup ENCHL +/// This is to specify effective address size different than the +/// default. For things with base or index regs, XED picks it up from the +/// registers. But for things that have implicit memops, or no base or index +/// reg, we must allow the user to set the address width directly. +static XED_INLINE void xed_addr(xed_encoder_instruction_t* x, + xed_uint_t width) { + x->effective_address_width = width; +} + + +/// @ingroup ENCHL +static XED_INLINE void xed_rep(xed_encoder_instruction_t* x) { + x->prefixes.s.rep=1; +} + +/// @ingroup ENCHL +static XED_INLINE void xed_repne(xed_encoder_instruction_t* x) { + x->prefixes.s.repne=1; +} + +/// @ingroup ENCHL +static XED_INLINE void xed_lock(xed_encoder_instruction_t* x) { + x->prefixes.s.lock=1; +} + + + + +/// @ingroup ENCHL +/// convert a #xed_encoder_instruction_t to a #xed_encoder_request_t for +/// encoding +XED_DLL_EXPORT xed_bool_t +xed_convert_to_encoder_request(xed_encoder_request_t* out, + xed_encoder_instruction_t* in); + +//@} + +//////////////////////////////////////////////////////////////////////////// +/* FIXME: rather than return the xed_encoder_instruction_t I can make + * another version that returns a xed_encoder_request_t. Saves silly + * copying. Although the xed_encoder_instruction_t might be handy for + * having code templates that get customized & passed to encoder later. */ +//////////////////////////////////////////////////////////////////////////// +/// @name Creating instructions from operands +//@{ + +/// @ingroup ENCHL +/// instruction with no operands +static XED_INLINE void xed_inst0( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->noperands = 0; +} + +/// @ingroup ENCHL +/// instruction with one operand +static XED_INLINE void xed_inst1( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_encoder_operand_t op0) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->operands[0] = op0; + inst->noperands = 1; +} + +/// @ingroup ENCHL +/// instruction with two operands +static XED_INLINE void xed_inst2( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_encoder_operand_t op0, + xed_encoder_operand_t op1) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->operands[0] = op0; + inst->operands[1] = op1; + inst->noperands = 2; +} + +/// @ingroup ENCHL +/// instruction with three operands +static XED_INLINE void xed_inst3( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_encoder_operand_t op0, + xed_encoder_operand_t op1, + xed_encoder_operand_t op2) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->operands[0] = op0; + inst->operands[1] = op1; + inst->operands[2] = op2; + inst->noperands = 3; +} + + +/// @ingroup ENCHL +/// instruction with four operands +static XED_INLINE void xed_inst4( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_encoder_operand_t op0, + xed_encoder_operand_t op1, + xed_encoder_operand_t op2, + xed_encoder_operand_t op3) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->operands[0] = op0; + inst->operands[1] = op1; + inst->operands[2] = op2; + inst->operands[3] = op3; + inst->noperands = 4; +} + +/// @ingroup ENCHL +/// instruction with five operands +static XED_INLINE void xed_inst5( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_encoder_operand_t op0, + xed_encoder_operand_t op1, + xed_encoder_operand_t op2, + xed_encoder_operand_t op3, + xed_encoder_operand_t op4) { + + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + inst->operands[0] = op0; + inst->operands[1] = op1; + inst->operands[2] = op2; + inst->operands[3] = op3; + inst->operands[4] = op4; + inst->noperands = 5; +} + + +/// @ingroup ENCHL +/// instruction with an array of operands. The maximum number is +/// XED_ENCODER_OPERANDS_MAX. The array's contents are copied. +static XED_INLINE void xed_inst( + xed_encoder_instruction_t* inst, + xed_state_t mode, + xed_iclass_enum_t iclass, + xed_uint_t effective_operand_width, + xed_uint_t number_of_operands, + const xed_encoder_operand_t* operand_array) { + + xed_uint_t i; + inst->mode=mode; + inst->iclass = iclass; + inst->effective_operand_width = effective_operand_width; + inst->effective_address_width = 0; + inst->prefixes.i = 0; + xed_assert(number_of_operands < XED_ENCODER_OPERANDS_MAX); + for(i=0;ioperands[i] = operand_array[i]; + } + inst->noperands = number_of_operands; +} + +//@} + +/* + xed_encoder_instruction_t x,y; + + xed_inst2(&x, state, XED_ICLASS_ADD, 32, + xed_reg(XED_REG_EAX), + xed_mem_bd(XED_REG_EDX, xed_disp(0x11223344, 32), 32)); + + xed_inst2(&y, state, XED_ICLASS_ADD, 32, + xed_reg(XED_REG_EAX), + xed_mem_gbisd(XED_REG_FS, XED_REG_EAX, XED_REG_ESI,4, + xed_disp(0x11223344, 32), 32)); + + */ + +#endif diff --git a/third_party/xed-intel64/include/xed-encoder-iforms.h b/third_party/xed-intel64/include/xed-encoder-iforms.h new file mode 100644 index 0000000..52558aa --- /dev/null +++ b/third_party/xed-intel64/include/xed-encoder-iforms.h @@ -0,0 +1,92 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-encoder-iforms.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ENCODER_IFORMS_H_) +# define _XED_ENCODER_IFORMS_H_ +#include "../../../third_party/xed-intel64/include/xed-types.h" +typedef struct xed_encoder_iforms_s { + xed_uint32_t x_MEMDISPv; + xed_uint32_t x_SIBBASE_ENCODE_SIB1; + xed_uint32_t x_VEX_MAP_ENC; + xed_uint32_t x_SIB_NT; + xed_uint32_t x_UIMM8_1; + xed_uint32_t x_SIBBASE_ENCODE; + xed_uint32_t x_VEX_ESCVL_ENC; + xed_uint32_t x_PREFIX_ENC; + xed_uint32_t x_VEXED_REX; + xed_uint32_t x_REMOVE_SEGMENT; + xed_uint32_t x_VSIB_ENC; + xed_uint32_t x_EVEX_REXB_ENC; + xed_uint32_t x_MODRM_RM_ENCODE_EA64_SIB0; + xed_uint32_t x_VEX_REXXB_ENC; + xed_uint32_t x_EVEX_REXRR_ENC; + xed_uint32_t x_AVX512_EVEX_BYTE3_ENC; + xed_uint32_t x_EVEX_REXW_VVVV_ENC; + xed_uint32_t x_VEX_REG_ENC; + xed_uint32_t x_UISA_SE_IMM8; + xed_uint32_t x_SIMM8; + xed_uint32_t x_XOP_MAP_ENC; + xed_uint32_t x_MODRM_RM_ENCODE_EA32_SIB0; + xed_uint32_t x_UIMM8; + xed_uint32_t x_MODRM_RM_ENCODE_EA16_SIB0; + xed_uint32_t x_XOP_REXXB_ENC; + xed_uint32_t x_EVEX_MAP_ENC; + xed_uint32_t x_MEMDISP8; + xed_uint32_t x_MODRM_RM_ENCODE; + xed_uint32_t x_REX_PREFIX_ENC; + xed_uint32_t x_UIMM16; + xed_uint32_t x_VEX_TYPE_ENC; + xed_uint32_t x_EVEX_UPP_ENC; + xed_uint32_t x_VEX_REXR_ENC; + xed_uint32_t x_BRDISP32; + xed_uint32_t x_MEMDISP32; + xed_uint32_t x_MEMDISP16; + xed_uint32_t x_SIBINDEX_ENCODE; + xed_uint32_t x_SE_IMM8; + xed_uint32_t x_UIMM32; + xed_uint32_t x_SIMMz; + xed_uint32_t x_UIMMv; + xed_uint32_t x_EVEX_62_REXR_ENC; + xed_uint32_t x_DISP_NT; + xed_uint32_t x_MODRM_MOD_ENCODE; + xed_uint32_t x_MEMDISP; + xed_uint32_t x_VSIB_ENC_BASE; + xed_uint32_t x_BRDISP8; + xed_uint32_t x_BRDISPz; + xed_uint32_t x_EVEX_REXX_ENC; + xed_uint32_t x_XOP_TYPE_ENC; +} xed_encoder_iforms_t; +#endif diff --git a/third_party/xed-intel64/include/xed-error-enum.h b/third_party/xed-intel64/include/xed-error-enum.h new file mode 100644 index 0000000..d72dd3a --- /dev/null +++ b/third_party/xed-intel64/include/xed-error-enum.h @@ -0,0 +1,77 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-error-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ERROR_ENUM_H_) +# define _XED_ERROR_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_ERROR_NONE, ///< There was no error + XED_ERROR_BUFFER_TOO_SHORT, ///< There were not enough bytes in the given buffer + XED_ERROR_GENERAL_ERROR, ///< XED could not decode the given instruction + XED_ERROR_INVALID_FOR_CHIP, ///< The instruciton is not valid for the specified chip + XED_ERROR_BAD_REGISTER, ///< XED could not decode the given instruction because an invalid register encoding was used. + XED_ERROR_BAD_LOCK_PREFIX, ///< A lock prefix was found where none is allowed. + XED_ERROR_BAD_REP_PREFIX, ///< An F2 or F3 prefix was found where none is allowed. + XED_ERROR_BAD_LEGACY_PREFIX, ///< A 66, F2 or F3 prefix was found where none is allowed. + XED_ERROR_BAD_REX_PREFIX, ///< A REX prefix was found where none is allowed. + XED_ERROR_BAD_EVEX_UBIT, ///< An illegal value for the EVEX.U bit was present in the instruction. + XED_ERROR_BAD_MAP, ///< An illegal value for the MAP field was detected in the instruction. + XED_ERROR_NO_OUTPUT_POINTER, ///< The output pointer for xed_agen was zero + XED_ERROR_NO_AGEN_CALL_BACK_REGISTERED, ///< One or both of the callbacks for xed_agen were missing. + XED_ERROR_BAD_MEMOP_INDEX, ///< Memop indices must be 0 or 1. + XED_ERROR_CALLBACK_PROBLEM, ///< The register or segment callback for xed_agen experienced a problem + XED_ERROR_GATHER_REGS, ///< The index, dest and mask regs for AVX2 gathers must be different. + XED_ERROR_INSTR_TOO_LONG, ///< Full decode of instruction would exeed 15B. + XED_ERROR_INVALID_MODE, ///< The instruction was not valid for the specified mode + XED_ERROR_LAST +} xed_error_enum_t; + +/// This converts strings to #xed_error_enum_t types. +/// @param s A C-string. +/// @return #xed_error_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_error_enum_t str2xed_error_enum_t(const char* s); +/// This converts strings to #xed_error_enum_t types. +/// @param p An enumeration element of type xed_error_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_error_enum_t2str(const xed_error_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_error_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_error_enum_t xed_error_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-exception-enum.h b/third_party/xed-intel64/include/xed-exception-enum.h new file mode 100644 index 0000000..292b0c9 --- /dev/null +++ b/third_party/xed-intel64/include/xed-exception-enum.h @@ -0,0 +1,101 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-exception-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_EXCEPTION_ENUM_H_) +# define _XED_EXCEPTION_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_EXCEPTION_INVALID, + XED_EXCEPTION_AVX512_E1, + XED_EXCEPTION_AVX512_E10, + XED_EXCEPTION_AVX512_E10NF, + XED_EXCEPTION_AVX512_E11, + XED_EXCEPTION_AVX512_E11NF, + XED_EXCEPTION_AVX512_E12, + XED_EXCEPTION_AVX512_E12NP, + XED_EXCEPTION_AVX512_E1NF, + XED_EXCEPTION_AVX512_E2, + XED_EXCEPTION_AVX512_E3, + XED_EXCEPTION_AVX512_E3NF, + XED_EXCEPTION_AVX512_E4, + XED_EXCEPTION_AVX512_E4NF, + XED_EXCEPTION_AVX512_E5, + XED_EXCEPTION_AVX512_E5NF, + XED_EXCEPTION_AVX512_E6, + XED_EXCEPTION_AVX512_E6NF, + XED_EXCEPTION_AVX512_E7NM, + XED_EXCEPTION_AVX512_E7NM128, + XED_EXCEPTION_AVX512_E9NF, + XED_EXCEPTION_AVX512_K20, + XED_EXCEPTION_AVX512_K21, + XED_EXCEPTION_AVX_TYPE_1, + XED_EXCEPTION_AVX_TYPE_2, + XED_EXCEPTION_AVX_TYPE_2D, + XED_EXCEPTION_AVX_TYPE_3, + XED_EXCEPTION_AVX_TYPE_4, + XED_EXCEPTION_AVX_TYPE_4M, + XED_EXCEPTION_AVX_TYPE_5, + XED_EXCEPTION_AVX_TYPE_5L, + XED_EXCEPTION_AVX_TYPE_6, + XED_EXCEPTION_AVX_TYPE_7, + XED_EXCEPTION_AVX_TYPE_8, + XED_EXCEPTION_SSE_TYPE_1, + XED_EXCEPTION_SSE_TYPE_2, + XED_EXCEPTION_SSE_TYPE_2D, + XED_EXCEPTION_SSE_TYPE_3, + XED_EXCEPTION_SSE_TYPE_4, + XED_EXCEPTION_SSE_TYPE_4M, + XED_EXCEPTION_SSE_TYPE_5, + XED_EXCEPTION_SSE_TYPE_7, + XED_EXCEPTION_LAST +} xed_exception_enum_t; + +/// This converts strings to #xed_exception_enum_t types. +/// @param s A C-string. +/// @return #xed_exception_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_exception_enum_t str2xed_exception_enum_t(const char* s); +/// This converts strings to #xed_exception_enum_t types. +/// @param p An enumeration element of type xed_exception_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_exception_enum_t2str(const xed_exception_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_exception_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_exception_enum_t xed_exception_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-extension-enum.h b/third_party/xed-intel64/include/xed-extension-enum.h new file mode 100644 index 0000000..4d6e96d --- /dev/null +++ b/third_party/xed-intel64/include/xed-extension-enum.h @@ -0,0 +1,113 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-extension-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_EXTENSION_ENUM_H_) +# define _XED_EXTENSION_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_EXTENSION_INVALID, + XED_EXTENSION_3DNOW, + XED_EXTENSION_AES, + XED_EXTENSION_AVX, + XED_EXTENSION_AVX2, + XED_EXTENSION_AVX2GATHER, + XED_EXTENSION_AVX512EVEX, + XED_EXTENSION_AVX512VEX, + XED_EXTENSION_AVXAES, + XED_EXTENSION_BASE, + XED_EXTENSION_BDW, + XED_EXTENSION_BMI1, + XED_EXTENSION_BMI2, + XED_EXTENSION_CLFLUSHOPT, + XED_EXTENSION_CLFSH, + XED_EXTENSION_CLWB, + XED_EXTENSION_F16C, + XED_EXTENSION_FMA, + XED_EXTENSION_FMA4, + XED_EXTENSION_INVPCID, + XED_EXTENSION_LONGMODE, + XED_EXTENSION_LZCNT, + XED_EXTENSION_MMX, + XED_EXTENSION_MOVBE, + XED_EXTENSION_MPX, + XED_EXTENSION_PAUSE, + XED_EXTENSION_PCLMULQDQ, + XED_EXTENSION_PCOMMIT, + XED_EXTENSION_PREFETCHWT1, + XED_EXTENSION_RDRAND, + XED_EXTENSION_RDSEED, + XED_EXTENSION_RDTSCP, + XED_EXTENSION_RDWRFSGS, + XED_EXTENSION_RTM, + XED_EXTENSION_SGX, + XED_EXTENSION_SHA, + XED_EXTENSION_SMAP, + XED_EXTENSION_SMX, + XED_EXTENSION_SSE, + XED_EXTENSION_SSE2, + XED_EXTENSION_SSE3, + XED_EXTENSION_SSE4, + XED_EXTENSION_SSE4A, + XED_EXTENSION_SSSE3, + XED_EXTENSION_SVM, + XED_EXTENSION_TBM, + XED_EXTENSION_VMFUNC, + XED_EXTENSION_VTX, + XED_EXTENSION_X87, + XED_EXTENSION_XOP, + XED_EXTENSION_XSAVE, + XED_EXTENSION_XSAVEC, + XED_EXTENSION_XSAVEOPT, + XED_EXTENSION_XSAVES, + XED_EXTENSION_LAST +} xed_extension_enum_t; + +/// This converts strings to #xed_extension_enum_t types. +/// @param s A C-string. +/// @return #xed_extension_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_extension_enum_t str2xed_extension_enum_t(const char* s); +/// This converts strings to #xed_extension_enum_t types. +/// @param p An enumeration element of type xed_extension_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_extension_enum_t2str(const xed_extension_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_extension_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_extension_enum_t xed_extension_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-flag-action-enum.h b/third_party/xed-intel64/include/xed-flag-action-enum.h new file mode 100644 index 0000000..1e9ec54 --- /dev/null +++ b/third_party/xed-intel64/include/xed-flag-action-enum.h @@ -0,0 +1,67 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-flag-action-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_FLAG_ACTION_ENUM_H_) +# define _XED_FLAG_ACTION_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_FLAG_ACTION_INVALID, + XED_FLAG_ACTION_u, ///< undefined (treated as a write) + XED_FLAG_ACTION_tst, ///< test (read) + XED_FLAG_ACTION_mod, ///< modification (write) + XED_FLAG_ACTION_0, ///< value will be zero (write) + XED_FLAG_ACTION_pop, ///< value comes from the stack (write) + XED_FLAG_ACTION_ah, ///< value comes from AH (write) + XED_FLAG_ACTION_1, ///< value will be 1 (write) + XED_FLAG_ACTION_LAST +} xed_flag_action_enum_t; + +/// This converts strings to #xed_flag_action_enum_t types. +/// @param s A C-string. +/// @return #xed_flag_action_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_flag_action_enum_t str2xed_flag_action_enum_t(const char* s); +/// This converts strings to #xed_flag_action_enum_t types. +/// @param p An enumeration element of type xed_flag_action_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_flag_action_enum_t2str(const xed_flag_action_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_flag_action_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_flag_action_enum_t xed_flag_action_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-flag-enum.h b/third_party/xed-intel64/include/xed-flag-enum.h new file mode 100644 index 0000000..8e0a17a --- /dev/null +++ b/third_party/xed-intel64/include/xed-flag-enum.h @@ -0,0 +1,81 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-flag-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_FLAG_ENUM_H_) +# define _XED_FLAG_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_FLAG_INVALID, + XED_FLAG_of, ///<< overflow flag + XED_FLAG_sf, ///< sign flag + XED_FLAG_zf, ///< zero flag + XED_FLAG_af, ///< auxilliary flag + XED_FLAG_pf, ///< parity flag + XED_FLAG_cf, ///< carry flag + XED_FLAG_df, ///< direction flag + XED_FLAG_vif, ///< virtual interrupt flag + XED_FLAG_iopl, ///< I/O privilege level + XED_FLAG_if, ///< interrupt flag + XED_FLAG_ac, ///< alignment check + XED_FLAG_vm, ///< virtual-8086 mode + XED_FLAG_rf, ///< resume flag + XED_FLAG_nt, ///< nested task + XED_FLAG_tf, ///< traf flag + XED_FLAG_id, ///< ID flag + XED_FLAG_vip, ///< virtual interrupt pending + XED_FLAG_fc0, ///< x87 FC0 flag + XED_FLAG_fc1, ///< x87 FC1 flag + XED_FLAG_fc2, ///< x87 FC2 flag + XED_FLAG_fc3, ///< x87 FC3 flag + XED_FLAG_LAST +} xed_flag_enum_t; + +/// This converts strings to #xed_flag_enum_t types. +/// @param s A C-string. +/// @return #xed_flag_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_flag_enum_t str2xed_flag_enum_t(const char* s); +/// This converts strings to #xed_flag_enum_t types. +/// @param p An enumeration element of type xed_flag_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_flag_enum_t2str(const xed_flag_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_flag_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_flag_enum_t xed_flag_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-flags.h b/third_party/xed-intel64/include/xed-flags.h new file mode 100644 index 0000000..8b320af --- /dev/null +++ b/third_party/xed-intel64/include/xed-flags.h @@ -0,0 +1,247 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-flags.h +/// + +#ifndef _XED_FLAGS_H_ +# define _XED_FLAGS_H_ + +#include "../../../third_party/xed-intel64/include/xed-flag-action-enum.h" +#include "../../../third_party/xed-intel64/include/xed-flag-enum.h" +#include "../../../third_party/xed-intel64/include/xed-gen-table-defs.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +//////////////////////////////////////////////////////////////////////////// +/// @ingroup FLAGS +/// a union of flags bits +union xed_flag_set_s { + xed_uint32_t flat; + struct { + xed_uint32_t cf:1; ///< bit 0 + xed_uint32_t must_be_1:1; + xed_uint32_t pf:1; + xed_uint32_t must_be_0a:1; + + xed_uint32_t af:1; ///< bit 4 + xed_uint32_t must_be_0b:1; + xed_uint32_t zf:1; + xed_uint32_t sf:1; + + xed_uint32_t tf:1; ///< bit 8 + xed_uint32_t _if:1; ///< underscore to avoid token clash + xed_uint32_t df:1; + xed_uint32_t of:1; + + xed_uint32_t iopl:2; ///< A 2-bit field, bits 12-13 + xed_uint32_t nt:1; + xed_uint32_t must_be_0c:1; + + xed_uint32_t rf:1; ///< bit 16 + xed_uint32_t vm:1; + xed_uint32_t ac:1; + xed_uint32_t vif:1; + + xed_uint32_t vip:1; ///< bit 20 + xed_uint32_t id:1; ///< bit 21 + xed_uint32_t must_be_0d:2; ///< bits 22-23 + + xed_uint32_t must_be_0e:4; ///< bits 24-27 + + // fc0,fc1,fc2,fc3 are not really part of rflags but I put them + // here to save space. These bits are only used for x87 + // instructions. + xed_uint32_t fc0:1; ///< x87 flag FC0 (not really part of rflags) + xed_uint32_t fc1:1; ///< x87 flag FC1 (not really part of rflags) + xed_uint32_t fc2:1; ///< x87 flag FC2 (not really part of rflags) + xed_uint32_t fc3:1; ///< x87 flag FC3 (not really part of rflags) + } s; + +}; + +typedef union xed_flag_set_s xed_flag_set_t; +/// @ingroup FLAGS +/// @name Flag-set accessors +//@{ +/// @ingroup FLAGS +/// print the flag set in the supplied buffer +XED_DLL_EXPORT int xed_flag_set_print(const xed_flag_set_t* p, char* buf, int buflen); +/// @ingroup FLAGS +/// returns true if this object has a subset of the flags of the +/// "other" object. +XED_DLL_EXPORT xed_bool_t xed_flag_set_is_subset_of(const xed_flag_set_t* p, + const xed_flag_set_t* other); +//@} + + +//////////////////////////////////////////////////////////////////////////// + +/// @ingroup FLAGS +/// Associated with each flag field there can be one action. +typedef struct xed_flag_enum_s { + xed_flag_enum_t flag; + // there are at most two actions per flag. The 2nd may be invalid. + xed_flag_action_enum_t action; +} xed_flag_action_t; + + + + +/// @ingroup FLAGS +/// @name Lowest-level flag-action accessors +//@{ +/// @ingroup FLAGS +/// get the name of the flag +XED_DLL_EXPORT xed_flag_enum_t +xed_flag_action_get_flag_name(const xed_flag_action_t* p); +/// @ingroup FLAGS +/// return the action +XED_DLL_EXPORT xed_flag_action_enum_t +xed_flag_action_get_action(const xed_flag_action_t* p, unsigned int i); +/// @ingroup FLAGS +/// returns true if the specified action is invalid. Only the 2nd flag might be invalid. +XED_DLL_EXPORT xed_bool_t +xed_flag_action_action_invalid(const xed_flag_action_enum_t a); +/// @ingroup FLAGS +/// print the flag & actions +XED_DLL_EXPORT int xed_flag_action_print(const xed_flag_action_t* p, char* buf, int buflen); +/// @ingroup FLAGS +/// returns true if either action is a read +XED_DLL_EXPORT xed_bool_t +xed_flag_action_read_flag(const xed_flag_action_t* p ); +/// @ingroup FLAGS +/// returns true if either action is a write +XED_DLL_EXPORT xed_bool_t +xed_flag_action_writes_flag(const xed_flag_action_t* p); + +/// @ingroup FLAGS +/// test to see if the specific action is a read +XED_DLL_EXPORT xed_bool_t +xed_flag_action_read_action( xed_flag_action_enum_t a); +/// @ingroup FLAGS +/// test to see if a specific action is a write +XED_DLL_EXPORT xed_bool_t +xed_flag_action_write_action( xed_flag_action_enum_t a); +//@} + +//////////////////////////////////////////////////////////////////////////// + +/// @ingroup FLAGS +/// A collection of #xed_flag_action_t's and unions of read and written flags +typedef struct xed_simple_flag_s +{ + ///number of flag actions associated with this record + xed_uint8_t nflags; + + xed_uint8_t may_write; /* 1/0, only using one bit */ + xed_uint8_t must_write; /* 1/0, only using one bit */ + + ///union of read flags + xed_flag_set_t read; + + /// union of written flags (includes undefined flags); + xed_flag_set_t written; + + /// union of undefined flags; + xed_flag_set_t undefined; + + // index in to the xed_flag_action_table. nflags limits the # of entries. + xed_uint16_t fa_index; + +} xed_simple_flag_t; + +/// @ingroup FLAGS +/// @name Accessing the simple flags (Mid-level access) +//@{ +/// @ingroup FLAGS +/// returns the number of flag-actions +XED_DLL_EXPORT unsigned int +xed_simple_flag_get_nflags(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// return union of bits for read flags +XED_DLL_EXPORT const xed_flag_set_t* +xed_simple_flag_get_read_flag_set(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// return union of bits for written flags +XED_DLL_EXPORT const xed_flag_set_t* +xed_simple_flag_get_written_flag_set(const xed_simple_flag_t* p); + + +/// @ingroup FLAGS +/// return union of bits for undefined flags +XED_DLL_EXPORT const xed_flag_set_t* +xed_simple_flag_get_undefined_flag_set(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// Indicates the flags are only conditionally written. Usally MAY-writes +/// of the flags instructions that are dependent on a REP count. +XED_DLL_EXPORT xed_bool_t xed_simple_flag_get_may_write(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// the flags always written +XED_DLL_EXPORT xed_bool_t xed_simple_flag_get_must_write(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// return the specific flag-action. Very detailed low level information +XED_DLL_EXPORT const xed_flag_action_t* +xed_simple_flag_get_flag_action(const xed_simple_flag_t* p, unsigned int i); + +/// @ingroup FLAGS +/// boolean test to see if flags are read, scans the flags +XED_DLL_EXPORT xed_bool_t +xed_simple_flag_reads_flags(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// boolean test to see if flags are written, scans the flags +XED_DLL_EXPORT xed_bool_t xed_simple_flag_writes_flags(const xed_simple_flag_t* p); + +/// @ingroup FLAGS +/// print the flags +XED_DLL_EXPORT int xed_simple_flag_print(const xed_simple_flag_t* p, char* buf, int buflen); + +/// @ingroup FLAGS +/// Return the flags as a mask +static XED_INLINE int xed_flag_set_mask(const xed_flag_set_t* p) { + return p->flat; // FIXME: could mask out the X87 flags +} + +//@} + +//////////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////////// + +#endif diff --git a/third_party/xed-intel64/include/xed-format-options.h b/third_party/xed-intel64/include/xed-format-options.h new file mode 100644 index 0000000..5fd3a6d --- /dev/null +++ b/third_party/xed-intel64/include/xed-format-options.h @@ -0,0 +1,75 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-format-options.h + + +#ifndef _XED_FORMAT_OPTIONS_H_ +# define _XED_FORMAT_OPTIONS_H_ +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +/// @name Formatting options +//@{ + +/// Options for the disasembly formatting functions. Set once during +/// initialization by a calling #xed_format_set_options +/// @ingroup PRINT +typedef struct { + /// by default, XED prints the hex address before any symbolic name for + /// branch targets. If set to zero, then XED will not print the hex + /// address before a valid symbolic name. + unsigned int hex_address_before_symbolic_name; + + /// Simple XML output format for the Intel syntax disassembly. + unsigned int xml_a; + /// Include flags in the XML formatting (must also supply xml_a) + unsigned int xml_f; + + /// omit unit scale "*1" + unsigned int omit_unit_scale; + + /// do not sign extend signed immediates + unsigned int no_sign_extend_signed_immediates; + + /// write-mask-with-curly-brackets, omit k0 + unsigned int write_mask_curly_k0; + +} xed_format_options_t; + +/// Optionally, customize the disassembly formatting options by passing +/// in a #xed_format_options_t structure. +/// @ingroup PRINT +XED_DLL_EXPORT void +xed_format_set_options(xed_format_options_t format_options); +//@} + +#endif diff --git a/third_party/xed-intel64/include/xed-gen-table-defs.h b/third_party/xed-intel64/include/xed-gen-table-defs.h new file mode 100644 index 0000000..a9d519e --- /dev/null +++ b/third_party/xed-intel64/include/xed-gen-table-defs.h @@ -0,0 +1,51 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-gen-table-defs.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_GEN_TABLE_DEFS_H_) +# define _XED_GEN_TABLE_DEFS_H_ +#define XED_ICLASS_NAME_STR_MAX 110 +#define XED_MAX_ATTRIBUTE_COUNT 86 +#define XED_MAX_INST_TABLE_NODES 6354 +#define XED_MAX_OPERAND_TABLE_NODES 1315 +#define XED_MAX_OPERAND_SEQUENCES 7705 +#define XED_MAX_REQUIRED_SIMPLE_FLAGS_ENTRIES 94 +#define XED_MAX_REQUIRED_COMPLEX_FLAGS_ENTRIES 37 +#define XED_MAX_GLOBAL_FLAG_ACTIONS 410 +#define XED_MAX_IFORMS_PER_ICLASS 28 +#define XED_MAX_REQUIRED_ATTRIBUTES 182 +#define XED_MAX_CONVERT_PATTERNS 5 +#define XED_MAX_DECORATIONS_PER_OPERAND 3 +#endif diff --git a/third_party/xed-intel64/include/xed-get-time.h b/third_party/xed-intel64/include/xed-get-time.h new file mode 100644 index 0000000..94f1d5b --- /dev/null +++ b/third_party/xed-intel64/include/xed-get-time.h @@ -0,0 +1,86 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#if !defined(_XED_GET_TIME_H_) +# define _XED_GET_TIME_H_ + +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + +# if defined(__INTEL_COMPILER) && __INTEL_COMPILER > 810 && !defined(_M_IA64) +# include +# endif +# if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 810 && !defined(_M_IA64) +# if __INTEL_COMPILER < 1000 +# pragma intrinsic(__rdtsc) +# endif +# endif +# if !defined(__INTEL_COMPILER) + /* MSVS8 and later */ +# if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(_M_IA64) +# include +# pragma intrinsic(__rdtsc) +# endif +# endif + + +///xed_get_time() must be compiled with gnu99 on linux to enable the asm() +///statements. If not gnu99, then xed_get_time() returns zero with gcc. GCC +///has no intrinsic for rdtsc. (The default for XED is to compile with +///-std=c99.) GCC allows __asm__ even under c99! +static XED_INLINE xed_uint64_t xed_get_time(void) { + xed_union64_t ticks; + // __STRICT_ANSI__ comes from the -std=c99 +# if defined(__GNUC__) //&& !defined(__STRICT_ANSI__) +# if defined(__i386__) || defined(i386) || defined(i686) || defined(__x86_64__) + __asm__ volatile ("rdtsc":"=a" (ticks.s.lo32), "=d"(ticks.s.hi32)); +# define FOUND_RDTSC +# endif +# endif +# if defined(__INTEL_COMPILER) && __INTEL_COMPILER>=810 && !defined(_M_IA64) + ticks.u64 = __rdtsc(); +# define FOUND_RDTSC +# endif +# if !defined(__INTEL_COMPILER) +# if !defined(FOUND_RDTSC) && defined(_MSC_VER) && _MSC_VER >= 1400 && \ + !defined(_M_IA64) && !defined(_MANAGED) /* MSVS7, 8 */ + ticks.u64 = __rdtsc(); +# define FOUND_RDTSC +# endif +# endif +# if !defined(FOUND_RDTSC) + ticks.u64 = 0; +# endif + return ticks.u64; +} + +#endif diff --git a/third_party/xed-intel64/include/xed-iclass-enum.h b/third_party/xed-intel64/include/xed-iclass-enum.h new file mode 100644 index 0000000..d7d1093 --- /dev/null +++ b/third_party/xed-intel64/include/xed-iclass-enum.h @@ -0,0 +1,1560 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-iclass-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ICLASS_ENUM_H_) +# define _XED_ICLASS_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_ICLASS_INVALID, + XED_ICLASS_AAA, + XED_ICLASS_AAD, + XED_ICLASS_AAM, + XED_ICLASS_AAS, + XED_ICLASS_ADC, + XED_ICLASS_ADCX, + XED_ICLASS_ADC_LOCK, + XED_ICLASS_ADD, + XED_ICLASS_ADDPD, + XED_ICLASS_ADDPS, + XED_ICLASS_ADDSD, + XED_ICLASS_ADDSS, + XED_ICLASS_ADDSUBPD, + XED_ICLASS_ADDSUBPS, + XED_ICLASS_ADD_LOCK, + XED_ICLASS_ADOX, + XED_ICLASS_AESDEC, + XED_ICLASS_AESDECLAST, + XED_ICLASS_AESENC, + XED_ICLASS_AESENCLAST, + XED_ICLASS_AESIMC, + XED_ICLASS_AESKEYGENASSIST, + XED_ICLASS_AND, + XED_ICLASS_ANDN, + XED_ICLASS_ANDNPD, + XED_ICLASS_ANDNPS, + XED_ICLASS_ANDPD, + XED_ICLASS_ANDPS, + XED_ICLASS_AND_LOCK, + XED_ICLASS_ARPL, + XED_ICLASS_BEXTR, + XED_ICLASS_BEXTR_XOP, + XED_ICLASS_BLCFILL, + XED_ICLASS_BLCI, + XED_ICLASS_BLCIC, + XED_ICLASS_BLCMSK, + XED_ICLASS_BLCS, + XED_ICLASS_BLENDPD, + XED_ICLASS_BLENDPS, + XED_ICLASS_BLENDVPD, + XED_ICLASS_BLENDVPS, + XED_ICLASS_BLSFILL, + XED_ICLASS_BLSI, + XED_ICLASS_BLSIC, + XED_ICLASS_BLSMSK, + XED_ICLASS_BLSR, + XED_ICLASS_BNDCL, + XED_ICLASS_BNDCN, + XED_ICLASS_BNDCU, + XED_ICLASS_BNDLDX, + XED_ICLASS_BNDMK, + XED_ICLASS_BNDMOV, + XED_ICLASS_BNDSTX, + XED_ICLASS_BOUND, + XED_ICLASS_BSF, + XED_ICLASS_BSR, + XED_ICLASS_BSWAP, + XED_ICLASS_BT, + XED_ICLASS_BTC, + XED_ICLASS_BTC_LOCK, + XED_ICLASS_BTR, + XED_ICLASS_BTR_LOCK, + XED_ICLASS_BTS, + XED_ICLASS_BTS_LOCK, + XED_ICLASS_BZHI, + XED_ICLASS_CALL_FAR, + XED_ICLASS_CALL_NEAR, + XED_ICLASS_CBW, + XED_ICLASS_CDQ, + XED_ICLASS_CDQE, + XED_ICLASS_CLAC, + XED_ICLASS_CLC, + XED_ICLASS_CLD, + XED_ICLASS_CLFLUSH, + XED_ICLASS_CLFLUSHOPT, + XED_ICLASS_CLGI, + XED_ICLASS_CLI, + XED_ICLASS_CLTS, + XED_ICLASS_CLWB, + XED_ICLASS_CMC, + XED_ICLASS_CMOVB, + XED_ICLASS_CMOVBE, + XED_ICLASS_CMOVL, + XED_ICLASS_CMOVLE, + XED_ICLASS_CMOVNB, + XED_ICLASS_CMOVNBE, + XED_ICLASS_CMOVNL, + XED_ICLASS_CMOVNLE, + XED_ICLASS_CMOVNO, + XED_ICLASS_CMOVNP, + XED_ICLASS_CMOVNS, + XED_ICLASS_CMOVNZ, + XED_ICLASS_CMOVO, + XED_ICLASS_CMOVP, + XED_ICLASS_CMOVS, + XED_ICLASS_CMOVZ, + XED_ICLASS_CMP, + XED_ICLASS_CMPPD, + XED_ICLASS_CMPPS, + XED_ICLASS_CMPSB, + XED_ICLASS_CMPSD, + XED_ICLASS_CMPSD_XMM, + XED_ICLASS_CMPSQ, + XED_ICLASS_CMPSS, + XED_ICLASS_CMPSW, + XED_ICLASS_CMPXCHG, + XED_ICLASS_CMPXCHG16B, + XED_ICLASS_CMPXCHG16B_LOCK, + XED_ICLASS_CMPXCHG8B, + XED_ICLASS_CMPXCHG8B_LOCK, + XED_ICLASS_CMPXCHG_LOCK, + XED_ICLASS_COMISD, + XED_ICLASS_COMISS, + XED_ICLASS_CPUID, + XED_ICLASS_CQO, + XED_ICLASS_CRC32, + XED_ICLASS_CVTDQ2PD, + XED_ICLASS_CVTDQ2PS, + XED_ICLASS_CVTPD2DQ, + XED_ICLASS_CVTPD2PI, + XED_ICLASS_CVTPD2PS, + XED_ICLASS_CVTPI2PD, + XED_ICLASS_CVTPI2PS, + XED_ICLASS_CVTPS2DQ, + XED_ICLASS_CVTPS2PD, + XED_ICLASS_CVTPS2PI, + XED_ICLASS_CVTSD2SI, + XED_ICLASS_CVTSD2SS, + XED_ICLASS_CVTSI2SD, + XED_ICLASS_CVTSI2SS, + XED_ICLASS_CVTSS2SD, + XED_ICLASS_CVTSS2SI, + XED_ICLASS_CVTTPD2DQ, + XED_ICLASS_CVTTPD2PI, + XED_ICLASS_CVTTPS2DQ, + XED_ICLASS_CVTTPS2PI, + XED_ICLASS_CVTTSD2SI, + XED_ICLASS_CVTTSS2SI, + XED_ICLASS_CWD, + XED_ICLASS_CWDE, + XED_ICLASS_DAA, + XED_ICLASS_DAS, + XED_ICLASS_DEC, + XED_ICLASS_DEC_LOCK, + XED_ICLASS_DIV, + XED_ICLASS_DIVPD, + XED_ICLASS_DIVPS, + XED_ICLASS_DIVSD, + XED_ICLASS_DIVSS, + XED_ICLASS_DPPD, + XED_ICLASS_DPPS, + XED_ICLASS_EMMS, + XED_ICLASS_ENCLS, + XED_ICLASS_ENCLU, + XED_ICLASS_ENTER, + XED_ICLASS_EXTRACTPS, + XED_ICLASS_EXTRQ, + XED_ICLASS_F2XM1, + XED_ICLASS_FABS, + XED_ICLASS_FADD, + XED_ICLASS_FADDP, + XED_ICLASS_FBLD, + XED_ICLASS_FBSTP, + XED_ICLASS_FCHS, + XED_ICLASS_FCMOVB, + XED_ICLASS_FCMOVBE, + XED_ICLASS_FCMOVE, + XED_ICLASS_FCMOVNB, + XED_ICLASS_FCMOVNBE, + XED_ICLASS_FCMOVNE, + XED_ICLASS_FCMOVNU, + XED_ICLASS_FCMOVU, + XED_ICLASS_FCOM, + XED_ICLASS_FCOMI, + XED_ICLASS_FCOMIP, + XED_ICLASS_FCOMP, + XED_ICLASS_FCOMPP, + XED_ICLASS_FCOS, + XED_ICLASS_FDECSTP, + XED_ICLASS_FDISI8087_NOP, + XED_ICLASS_FDIV, + XED_ICLASS_FDIVP, + XED_ICLASS_FDIVR, + XED_ICLASS_FDIVRP, + XED_ICLASS_FEMMS, + XED_ICLASS_FENI8087_NOP, + XED_ICLASS_FFREE, + XED_ICLASS_FFREEP, + XED_ICLASS_FIADD, + XED_ICLASS_FICOM, + XED_ICLASS_FICOMP, + XED_ICLASS_FIDIV, + XED_ICLASS_FIDIVR, + XED_ICLASS_FILD, + XED_ICLASS_FIMUL, + XED_ICLASS_FINCSTP, + XED_ICLASS_FIST, + XED_ICLASS_FISTP, + XED_ICLASS_FISTTP, + XED_ICLASS_FISUB, + XED_ICLASS_FISUBR, + XED_ICLASS_FLD, + XED_ICLASS_FLD1, + XED_ICLASS_FLDCW, + XED_ICLASS_FLDENV, + XED_ICLASS_FLDL2E, + XED_ICLASS_FLDL2T, + XED_ICLASS_FLDLG2, + XED_ICLASS_FLDLN2, + XED_ICLASS_FLDPI, + XED_ICLASS_FLDZ, + XED_ICLASS_FMUL, + XED_ICLASS_FMULP, + XED_ICLASS_FNCLEX, + XED_ICLASS_FNINIT, + XED_ICLASS_FNOP, + XED_ICLASS_FNSAVE, + XED_ICLASS_FNSTCW, + XED_ICLASS_FNSTENV, + XED_ICLASS_FNSTSW, + XED_ICLASS_FPATAN, + XED_ICLASS_FPREM, + XED_ICLASS_FPREM1, + XED_ICLASS_FPTAN, + XED_ICLASS_FRNDINT, + XED_ICLASS_FRSTOR, + XED_ICLASS_FSCALE, + XED_ICLASS_FSETPM287_NOP, + XED_ICLASS_FSIN, + XED_ICLASS_FSINCOS, + XED_ICLASS_FSQRT, + XED_ICLASS_FST, + XED_ICLASS_FSTP, + XED_ICLASS_FSTPNCE, + XED_ICLASS_FSUB, + XED_ICLASS_FSUBP, + XED_ICLASS_FSUBR, + XED_ICLASS_FSUBRP, + XED_ICLASS_FTST, + XED_ICLASS_FUCOM, + XED_ICLASS_FUCOMI, + XED_ICLASS_FUCOMIP, + XED_ICLASS_FUCOMP, + XED_ICLASS_FUCOMPP, + XED_ICLASS_FWAIT, + XED_ICLASS_FXAM, + XED_ICLASS_FXCH, + XED_ICLASS_FXRSTOR, + XED_ICLASS_FXRSTOR64, + XED_ICLASS_FXSAVE, + XED_ICLASS_FXSAVE64, + XED_ICLASS_FXTRACT, + XED_ICLASS_FYL2X, + XED_ICLASS_FYL2XP1, + XED_ICLASS_GETSEC, + XED_ICLASS_HADDPD, + XED_ICLASS_HADDPS, + XED_ICLASS_HLT, + XED_ICLASS_HSUBPD, + XED_ICLASS_HSUBPS, + XED_ICLASS_IDIV, + XED_ICLASS_IMUL, + XED_ICLASS_IN, + XED_ICLASS_INC, + XED_ICLASS_INC_LOCK, + XED_ICLASS_INSB, + XED_ICLASS_INSD, + XED_ICLASS_INSERTPS, + XED_ICLASS_INSERTQ, + XED_ICLASS_INSW, + XED_ICLASS_INT, + XED_ICLASS_INT1, + XED_ICLASS_INT3, + XED_ICLASS_INTO, + XED_ICLASS_INVD, + XED_ICLASS_INVEPT, + XED_ICLASS_INVLPG, + XED_ICLASS_INVLPGA, + XED_ICLASS_INVPCID, + XED_ICLASS_INVVPID, + XED_ICLASS_IRET, + XED_ICLASS_IRETD, + XED_ICLASS_IRETQ, + XED_ICLASS_JB, + XED_ICLASS_JBE, + XED_ICLASS_JCXZ, + XED_ICLASS_JECXZ, + XED_ICLASS_JL, + XED_ICLASS_JLE, + XED_ICLASS_JMP, + XED_ICLASS_JMP_FAR, + XED_ICLASS_JNB, + XED_ICLASS_JNBE, + XED_ICLASS_JNL, + XED_ICLASS_JNLE, + XED_ICLASS_JNO, + XED_ICLASS_JNP, + XED_ICLASS_JNS, + XED_ICLASS_JNZ, + XED_ICLASS_JO, + XED_ICLASS_JP, + XED_ICLASS_JRCXZ, + XED_ICLASS_JS, + XED_ICLASS_JZ, + XED_ICLASS_KADDB, + XED_ICLASS_KADDD, + XED_ICLASS_KADDQ, + XED_ICLASS_KADDW, + XED_ICLASS_KANDB, + XED_ICLASS_KANDD, + XED_ICLASS_KANDNB, + XED_ICLASS_KANDND, + XED_ICLASS_KANDNQ, + XED_ICLASS_KANDNW, + XED_ICLASS_KANDQ, + XED_ICLASS_KANDW, + XED_ICLASS_KMOVB, + XED_ICLASS_KMOVD, + XED_ICLASS_KMOVQ, + XED_ICLASS_KMOVW, + XED_ICLASS_KNOTB, + XED_ICLASS_KNOTD, + XED_ICLASS_KNOTQ, + XED_ICLASS_KNOTW, + XED_ICLASS_KORB, + XED_ICLASS_KORD, + XED_ICLASS_KORQ, + XED_ICLASS_KORTESTB, + XED_ICLASS_KORTESTD, + XED_ICLASS_KORTESTQ, + XED_ICLASS_KORTESTW, + XED_ICLASS_KORW, + XED_ICLASS_KSHIFTLB, + XED_ICLASS_KSHIFTLD, + XED_ICLASS_KSHIFTLQ, + XED_ICLASS_KSHIFTLW, + XED_ICLASS_KSHIFTRB, + XED_ICLASS_KSHIFTRD, + XED_ICLASS_KSHIFTRQ, + XED_ICLASS_KSHIFTRW, + XED_ICLASS_KTESTB, + XED_ICLASS_KTESTD, + XED_ICLASS_KTESTQ, + XED_ICLASS_KTESTW, + XED_ICLASS_KUNPCKBW, + XED_ICLASS_KUNPCKDQ, + XED_ICLASS_KUNPCKWD, + XED_ICLASS_KXNORB, + XED_ICLASS_KXNORD, + XED_ICLASS_KXNORQ, + XED_ICLASS_KXNORW, + XED_ICLASS_KXORB, + XED_ICLASS_KXORD, + XED_ICLASS_KXORQ, + XED_ICLASS_KXORW, + XED_ICLASS_LAHF, + XED_ICLASS_LAR, + XED_ICLASS_LDDQU, + XED_ICLASS_LDMXCSR, + XED_ICLASS_LDS, + XED_ICLASS_LEA, + XED_ICLASS_LEAVE, + XED_ICLASS_LES, + XED_ICLASS_LFENCE, + XED_ICLASS_LFS, + XED_ICLASS_LGDT, + XED_ICLASS_LGS, + XED_ICLASS_LIDT, + XED_ICLASS_LLDT, + XED_ICLASS_LLWPCB, + XED_ICLASS_LMSW, + XED_ICLASS_LODSB, + XED_ICLASS_LODSD, + XED_ICLASS_LODSQ, + XED_ICLASS_LODSW, + XED_ICLASS_LOOP, + XED_ICLASS_LOOPE, + XED_ICLASS_LOOPNE, + XED_ICLASS_LSL, + XED_ICLASS_LSS, + XED_ICLASS_LTR, + XED_ICLASS_LWPINS, + XED_ICLASS_LWPVAL, + XED_ICLASS_LZCNT, + XED_ICLASS_MASKMOVDQU, + XED_ICLASS_MASKMOVQ, + XED_ICLASS_MAXPD, + XED_ICLASS_MAXPS, + XED_ICLASS_MAXSD, + XED_ICLASS_MAXSS, + XED_ICLASS_MFENCE, + XED_ICLASS_MINPD, + XED_ICLASS_MINPS, + XED_ICLASS_MINSD, + XED_ICLASS_MINSS, + XED_ICLASS_MONITOR, + XED_ICLASS_MOV, + XED_ICLASS_MOVAPD, + XED_ICLASS_MOVAPS, + XED_ICLASS_MOVBE, + XED_ICLASS_MOVD, + XED_ICLASS_MOVDDUP, + XED_ICLASS_MOVDQ2Q, + XED_ICLASS_MOVDQA, + XED_ICLASS_MOVDQU, + XED_ICLASS_MOVHLPS, + XED_ICLASS_MOVHPD, + XED_ICLASS_MOVHPS, + XED_ICLASS_MOVLHPS, + XED_ICLASS_MOVLPD, + XED_ICLASS_MOVLPS, + XED_ICLASS_MOVMSKPD, + XED_ICLASS_MOVMSKPS, + XED_ICLASS_MOVNTDQ, + XED_ICLASS_MOVNTDQA, + XED_ICLASS_MOVNTI, + XED_ICLASS_MOVNTPD, + XED_ICLASS_MOVNTPS, + XED_ICLASS_MOVNTQ, + XED_ICLASS_MOVNTSD, + XED_ICLASS_MOVNTSS, + XED_ICLASS_MOVQ, + XED_ICLASS_MOVQ2DQ, + XED_ICLASS_MOVSB, + XED_ICLASS_MOVSD, + XED_ICLASS_MOVSD_XMM, + XED_ICLASS_MOVSHDUP, + XED_ICLASS_MOVSLDUP, + XED_ICLASS_MOVSQ, + XED_ICLASS_MOVSS, + XED_ICLASS_MOVSW, + XED_ICLASS_MOVSX, + XED_ICLASS_MOVSXD, + XED_ICLASS_MOVUPD, + XED_ICLASS_MOVUPS, + XED_ICLASS_MOVZX, + XED_ICLASS_MOV_CR, + XED_ICLASS_MOV_DR, + XED_ICLASS_MPSADBW, + XED_ICLASS_MUL, + XED_ICLASS_MULPD, + XED_ICLASS_MULPS, + XED_ICLASS_MULSD, + XED_ICLASS_MULSS, + XED_ICLASS_MULX, + XED_ICLASS_MWAIT, + XED_ICLASS_NEG, + XED_ICLASS_NEG_LOCK, + XED_ICLASS_NOP, + XED_ICLASS_NOP2, + XED_ICLASS_NOP3, + XED_ICLASS_NOP4, + XED_ICLASS_NOP5, + XED_ICLASS_NOP6, + XED_ICLASS_NOP7, + XED_ICLASS_NOP8, + XED_ICLASS_NOP9, + XED_ICLASS_NOT, + XED_ICLASS_NOT_LOCK, + XED_ICLASS_OR, + XED_ICLASS_ORPD, + XED_ICLASS_ORPS, + XED_ICLASS_OR_LOCK, + XED_ICLASS_OUT, + XED_ICLASS_OUTSB, + XED_ICLASS_OUTSD, + XED_ICLASS_OUTSW, + XED_ICLASS_PABSB, + XED_ICLASS_PABSD, + XED_ICLASS_PABSW, + XED_ICLASS_PACKSSDW, + XED_ICLASS_PACKSSWB, + XED_ICLASS_PACKUSDW, + XED_ICLASS_PACKUSWB, + XED_ICLASS_PADDB, + XED_ICLASS_PADDD, + XED_ICLASS_PADDQ, + XED_ICLASS_PADDSB, + XED_ICLASS_PADDSW, + XED_ICLASS_PADDUSB, + XED_ICLASS_PADDUSW, + XED_ICLASS_PADDW, + XED_ICLASS_PALIGNR, + XED_ICLASS_PAND, + XED_ICLASS_PANDN, + XED_ICLASS_PAUSE, + XED_ICLASS_PAVGB, + XED_ICLASS_PAVGUSB, + XED_ICLASS_PAVGW, + XED_ICLASS_PBLENDVB, + XED_ICLASS_PBLENDW, + XED_ICLASS_PCLMULQDQ, + XED_ICLASS_PCMPEQB, + XED_ICLASS_PCMPEQD, + XED_ICLASS_PCMPEQQ, + XED_ICLASS_PCMPEQW, + XED_ICLASS_PCMPESTRI, + XED_ICLASS_PCMPESTRM, + XED_ICLASS_PCMPGTB, + XED_ICLASS_PCMPGTD, + XED_ICLASS_PCMPGTQ, + XED_ICLASS_PCMPGTW, + XED_ICLASS_PCMPISTRI, + XED_ICLASS_PCMPISTRM, + XED_ICLASS_PCOMMIT, + XED_ICLASS_PDEP, + XED_ICLASS_PEXT, + XED_ICLASS_PEXTRB, + XED_ICLASS_PEXTRD, + XED_ICLASS_PEXTRQ, + XED_ICLASS_PEXTRW, + XED_ICLASS_PEXTRW_SSE4, + XED_ICLASS_PF2ID, + XED_ICLASS_PF2IW, + XED_ICLASS_PFACC, + XED_ICLASS_PFADD, + XED_ICLASS_PFCMPEQ, + XED_ICLASS_PFCMPGE, + XED_ICLASS_PFCMPGT, + XED_ICLASS_PFCPIT1, + XED_ICLASS_PFMAX, + XED_ICLASS_PFMIN, + XED_ICLASS_PFMUL, + XED_ICLASS_PFNACC, + XED_ICLASS_PFPNACC, + XED_ICLASS_PFRCP, + XED_ICLASS_PFRCPIT2, + XED_ICLASS_PFRSQIT1, + XED_ICLASS_PFSQRT, + XED_ICLASS_PFSUB, + XED_ICLASS_PFSUBR, + XED_ICLASS_PHADDD, + XED_ICLASS_PHADDSW, + XED_ICLASS_PHADDW, + XED_ICLASS_PHMINPOSUW, + XED_ICLASS_PHSUBD, + XED_ICLASS_PHSUBSW, + XED_ICLASS_PHSUBW, + XED_ICLASS_PI2FD, + XED_ICLASS_PI2FW, + XED_ICLASS_PINSRB, + XED_ICLASS_PINSRD, + XED_ICLASS_PINSRQ, + XED_ICLASS_PINSRW, + XED_ICLASS_PMADDUBSW, + XED_ICLASS_PMADDWD, + XED_ICLASS_PMAXSB, + XED_ICLASS_PMAXSD, + XED_ICLASS_PMAXSW, + XED_ICLASS_PMAXUB, + XED_ICLASS_PMAXUD, + XED_ICLASS_PMAXUW, + XED_ICLASS_PMINSB, + XED_ICLASS_PMINSD, + XED_ICLASS_PMINSW, + XED_ICLASS_PMINUB, + XED_ICLASS_PMINUD, + XED_ICLASS_PMINUW, + XED_ICLASS_PMOVMSKB, + XED_ICLASS_PMOVSXBD, + XED_ICLASS_PMOVSXBQ, + XED_ICLASS_PMOVSXBW, + XED_ICLASS_PMOVSXDQ, + XED_ICLASS_PMOVSXWD, + XED_ICLASS_PMOVSXWQ, + XED_ICLASS_PMOVZXBD, + XED_ICLASS_PMOVZXBQ, + XED_ICLASS_PMOVZXBW, + XED_ICLASS_PMOVZXDQ, + XED_ICLASS_PMOVZXWD, + XED_ICLASS_PMOVZXWQ, + XED_ICLASS_PMULDQ, + XED_ICLASS_PMULHRSW, + XED_ICLASS_PMULHRW, + XED_ICLASS_PMULHUW, + XED_ICLASS_PMULHW, + XED_ICLASS_PMULLD, + XED_ICLASS_PMULLW, + XED_ICLASS_PMULUDQ, + XED_ICLASS_POP, + XED_ICLASS_POPA, + XED_ICLASS_POPAD, + XED_ICLASS_POPCNT, + XED_ICLASS_POPF, + XED_ICLASS_POPFD, + XED_ICLASS_POPFQ, + XED_ICLASS_POR, + XED_ICLASS_PREFETCHNTA, + XED_ICLASS_PREFETCHT0, + XED_ICLASS_PREFETCHT1, + XED_ICLASS_PREFETCHT2, + XED_ICLASS_PREFETCHW, + XED_ICLASS_PREFETCHWT1, + XED_ICLASS_PREFETCH_EXCLUSIVE, + XED_ICLASS_PREFETCH_RESERVED, + XED_ICLASS_PSADBW, + XED_ICLASS_PSHUFB, + XED_ICLASS_PSHUFD, + XED_ICLASS_PSHUFHW, + XED_ICLASS_PSHUFLW, + XED_ICLASS_PSHUFW, + XED_ICLASS_PSIGNB, + XED_ICLASS_PSIGND, + XED_ICLASS_PSIGNW, + XED_ICLASS_PSLLD, + XED_ICLASS_PSLLDQ, + XED_ICLASS_PSLLQ, + XED_ICLASS_PSLLW, + XED_ICLASS_PSRAD, + XED_ICLASS_PSRAW, + XED_ICLASS_PSRLD, + XED_ICLASS_PSRLDQ, + XED_ICLASS_PSRLQ, + XED_ICLASS_PSRLW, + XED_ICLASS_PSUBB, + XED_ICLASS_PSUBD, + XED_ICLASS_PSUBQ, + XED_ICLASS_PSUBSB, + XED_ICLASS_PSUBSW, + XED_ICLASS_PSUBUSB, + XED_ICLASS_PSUBUSW, + XED_ICLASS_PSUBW, + XED_ICLASS_PSWAPD, + XED_ICLASS_PTEST, + XED_ICLASS_PUNPCKHBW, + XED_ICLASS_PUNPCKHDQ, + XED_ICLASS_PUNPCKHQDQ, + XED_ICLASS_PUNPCKHWD, + XED_ICLASS_PUNPCKLBW, + XED_ICLASS_PUNPCKLDQ, + XED_ICLASS_PUNPCKLQDQ, + XED_ICLASS_PUNPCKLWD, + XED_ICLASS_PUSH, + XED_ICLASS_PUSHA, + XED_ICLASS_PUSHAD, + XED_ICLASS_PUSHF, + XED_ICLASS_PUSHFD, + XED_ICLASS_PUSHFQ, + XED_ICLASS_PXOR, + XED_ICLASS_RCL, + XED_ICLASS_RCPPS, + XED_ICLASS_RCPSS, + XED_ICLASS_RCR, + XED_ICLASS_RDFSBASE, + XED_ICLASS_RDGSBASE, + XED_ICLASS_RDMSR, + XED_ICLASS_RDPMC, + XED_ICLASS_RDRAND, + XED_ICLASS_RDSEED, + XED_ICLASS_RDTSC, + XED_ICLASS_RDTSCP, + XED_ICLASS_REPE_CMPSB, + XED_ICLASS_REPE_CMPSD, + XED_ICLASS_REPE_CMPSQ, + XED_ICLASS_REPE_CMPSW, + XED_ICLASS_REPE_SCASB, + XED_ICLASS_REPE_SCASD, + XED_ICLASS_REPE_SCASQ, + XED_ICLASS_REPE_SCASW, + XED_ICLASS_REPNE_CMPSB, + XED_ICLASS_REPNE_CMPSD, + XED_ICLASS_REPNE_CMPSQ, + XED_ICLASS_REPNE_CMPSW, + XED_ICLASS_REPNE_SCASB, + XED_ICLASS_REPNE_SCASD, + XED_ICLASS_REPNE_SCASQ, + XED_ICLASS_REPNE_SCASW, + XED_ICLASS_REP_INSB, + XED_ICLASS_REP_INSD, + XED_ICLASS_REP_INSW, + XED_ICLASS_REP_LODSB, + XED_ICLASS_REP_LODSD, + XED_ICLASS_REP_LODSQ, + XED_ICLASS_REP_LODSW, + XED_ICLASS_REP_MOVSB, + XED_ICLASS_REP_MOVSD, + XED_ICLASS_REP_MOVSQ, + XED_ICLASS_REP_MOVSW, + XED_ICLASS_REP_OUTSB, + XED_ICLASS_REP_OUTSD, + XED_ICLASS_REP_OUTSW, + XED_ICLASS_REP_STOSB, + XED_ICLASS_REP_STOSD, + XED_ICLASS_REP_STOSQ, + XED_ICLASS_REP_STOSW, + XED_ICLASS_RET_FAR, + XED_ICLASS_RET_NEAR, + XED_ICLASS_ROL, + XED_ICLASS_ROR, + XED_ICLASS_RORX, + XED_ICLASS_ROUNDPD, + XED_ICLASS_ROUNDPS, + XED_ICLASS_ROUNDSD, + XED_ICLASS_ROUNDSS, + XED_ICLASS_RSM, + XED_ICLASS_RSQRTPS, + XED_ICLASS_RSQRTSS, + XED_ICLASS_SAHF, + XED_ICLASS_SALC, + XED_ICLASS_SAR, + XED_ICLASS_SARX, + XED_ICLASS_SBB, + XED_ICLASS_SBB_LOCK, + XED_ICLASS_SCASB, + XED_ICLASS_SCASD, + XED_ICLASS_SCASQ, + XED_ICLASS_SCASW, + XED_ICLASS_SETB, + XED_ICLASS_SETBE, + XED_ICLASS_SETL, + XED_ICLASS_SETLE, + XED_ICLASS_SETNB, + XED_ICLASS_SETNBE, + XED_ICLASS_SETNL, + XED_ICLASS_SETNLE, + XED_ICLASS_SETNO, + XED_ICLASS_SETNP, + XED_ICLASS_SETNS, + XED_ICLASS_SETNZ, + XED_ICLASS_SETO, + XED_ICLASS_SETP, + XED_ICLASS_SETS, + XED_ICLASS_SETZ, + XED_ICLASS_SFENCE, + XED_ICLASS_SGDT, + XED_ICLASS_SHA1MSG1, + XED_ICLASS_SHA1MSG2, + XED_ICLASS_SHA1NEXTE, + XED_ICLASS_SHA1RNDS4, + XED_ICLASS_SHA256MSG1, + XED_ICLASS_SHA256MSG2, + XED_ICLASS_SHA256RNDS2, + XED_ICLASS_SHL, + XED_ICLASS_SHLD, + XED_ICLASS_SHLX, + XED_ICLASS_SHR, + XED_ICLASS_SHRD, + XED_ICLASS_SHRX, + XED_ICLASS_SHUFPD, + XED_ICLASS_SHUFPS, + XED_ICLASS_SIDT, + XED_ICLASS_SKINIT, + XED_ICLASS_SLDT, + XED_ICLASS_SLWPCB, + XED_ICLASS_SMSW, + XED_ICLASS_SQRTPD, + XED_ICLASS_SQRTPS, + XED_ICLASS_SQRTSD, + XED_ICLASS_SQRTSS, + XED_ICLASS_STAC, + XED_ICLASS_STC, + XED_ICLASS_STD, + XED_ICLASS_STGI, + XED_ICLASS_STI, + XED_ICLASS_STMXCSR, + XED_ICLASS_STOSB, + XED_ICLASS_STOSD, + XED_ICLASS_STOSQ, + XED_ICLASS_STOSW, + XED_ICLASS_STR, + XED_ICLASS_SUB, + XED_ICLASS_SUBPD, + XED_ICLASS_SUBPS, + XED_ICLASS_SUBSD, + XED_ICLASS_SUBSS, + XED_ICLASS_SUB_LOCK, + XED_ICLASS_SWAPGS, + XED_ICLASS_SYSCALL, + XED_ICLASS_SYSCALL_AMD, + XED_ICLASS_SYSENTER, + XED_ICLASS_SYSEXIT, + XED_ICLASS_SYSRET, + XED_ICLASS_SYSRET_AMD, + XED_ICLASS_T1MSKC, + XED_ICLASS_TEST, + XED_ICLASS_TZCNT, + XED_ICLASS_TZMSK, + XED_ICLASS_UCOMISD, + XED_ICLASS_UCOMISS, + XED_ICLASS_UD2, + XED_ICLASS_UNPCKHPD, + XED_ICLASS_UNPCKHPS, + XED_ICLASS_UNPCKLPD, + XED_ICLASS_UNPCKLPS, + XED_ICLASS_VADDPD, + XED_ICLASS_VADDPS, + XED_ICLASS_VADDSD, + XED_ICLASS_VADDSS, + XED_ICLASS_VADDSUBPD, + XED_ICLASS_VADDSUBPS, + XED_ICLASS_VAESDEC, + XED_ICLASS_VAESDECLAST, + XED_ICLASS_VAESENC, + XED_ICLASS_VAESENCLAST, + XED_ICLASS_VAESIMC, + XED_ICLASS_VAESKEYGENASSIST, + XED_ICLASS_VALIGND, + XED_ICLASS_VALIGNQ, + XED_ICLASS_VANDNPD, + XED_ICLASS_VANDNPS, + XED_ICLASS_VANDPD, + XED_ICLASS_VANDPS, + XED_ICLASS_VBLENDMPD, + XED_ICLASS_VBLENDMPS, + XED_ICLASS_VBLENDPD, + XED_ICLASS_VBLENDPS, + XED_ICLASS_VBLENDVPD, + XED_ICLASS_VBLENDVPS, + XED_ICLASS_VBROADCASTF128, + XED_ICLASS_VBROADCASTF32X2, + XED_ICLASS_VBROADCASTF32X4, + XED_ICLASS_VBROADCASTF32X8, + XED_ICLASS_VBROADCASTF64X2, + XED_ICLASS_VBROADCASTF64X4, + XED_ICLASS_VBROADCASTI128, + XED_ICLASS_VBROADCASTI32X2, + XED_ICLASS_VBROADCASTI32X4, + XED_ICLASS_VBROADCASTI32X8, + XED_ICLASS_VBROADCASTI64X2, + XED_ICLASS_VBROADCASTI64X4, + XED_ICLASS_VBROADCASTSD, + XED_ICLASS_VBROADCASTSS, + XED_ICLASS_VCMPPD, + XED_ICLASS_VCMPPS, + XED_ICLASS_VCMPSD, + XED_ICLASS_VCMPSS, + XED_ICLASS_VCOMISD, + XED_ICLASS_VCOMISS, + XED_ICLASS_VCOMPRESSPD, + XED_ICLASS_VCOMPRESSPS, + XED_ICLASS_VCVTDQ2PD, + XED_ICLASS_VCVTDQ2PS, + XED_ICLASS_VCVTPD2DQ, + XED_ICLASS_VCVTPD2PS, + XED_ICLASS_VCVTPD2QQ, + XED_ICLASS_VCVTPD2UDQ, + XED_ICLASS_VCVTPD2UQQ, + XED_ICLASS_VCVTPH2PS, + XED_ICLASS_VCVTPS2DQ, + XED_ICLASS_VCVTPS2PD, + XED_ICLASS_VCVTPS2PH, + XED_ICLASS_VCVTPS2QQ, + XED_ICLASS_VCVTPS2UDQ, + XED_ICLASS_VCVTPS2UQQ, + XED_ICLASS_VCVTQQ2PD, + XED_ICLASS_VCVTQQ2PS, + XED_ICLASS_VCVTSD2SI, + XED_ICLASS_VCVTSD2SS, + XED_ICLASS_VCVTSD2USI, + XED_ICLASS_VCVTSI2SD, + XED_ICLASS_VCVTSI2SS, + XED_ICLASS_VCVTSS2SD, + XED_ICLASS_VCVTSS2SI, + XED_ICLASS_VCVTSS2USI, + XED_ICLASS_VCVTTPD2DQ, + XED_ICLASS_VCVTTPD2QQ, + XED_ICLASS_VCVTTPD2UDQ, + XED_ICLASS_VCVTTPD2UQQ, + XED_ICLASS_VCVTTPS2DQ, + XED_ICLASS_VCVTTPS2QQ, + XED_ICLASS_VCVTTPS2UDQ, + XED_ICLASS_VCVTTPS2UQQ, + XED_ICLASS_VCVTTSD2SI, + XED_ICLASS_VCVTTSD2USI, + XED_ICLASS_VCVTTSS2SI, + XED_ICLASS_VCVTTSS2USI, + XED_ICLASS_VCVTUDQ2PD, + XED_ICLASS_VCVTUDQ2PS, + XED_ICLASS_VCVTUQQ2PD, + XED_ICLASS_VCVTUQQ2PS, + XED_ICLASS_VCVTUSI2SD, + XED_ICLASS_VCVTUSI2SS, + XED_ICLASS_VDBPSADBW, + XED_ICLASS_VDIVPD, + XED_ICLASS_VDIVPS, + XED_ICLASS_VDIVSD, + XED_ICLASS_VDIVSS, + XED_ICLASS_VDPPD, + XED_ICLASS_VDPPS, + XED_ICLASS_VERR, + XED_ICLASS_VERW, + XED_ICLASS_VEXP2PD, + XED_ICLASS_VEXP2PS, + XED_ICLASS_VEXPANDPD, + XED_ICLASS_VEXPANDPS, + XED_ICLASS_VEXTRACTF128, + XED_ICLASS_VEXTRACTF32X4, + XED_ICLASS_VEXTRACTF32X8, + XED_ICLASS_VEXTRACTF64X2, + XED_ICLASS_VEXTRACTF64X4, + XED_ICLASS_VEXTRACTI128, + XED_ICLASS_VEXTRACTI32X4, + XED_ICLASS_VEXTRACTI32X8, + XED_ICLASS_VEXTRACTI64X2, + XED_ICLASS_VEXTRACTI64X4, + XED_ICLASS_VEXTRACTPS, + XED_ICLASS_VFIXUPIMMPD, + XED_ICLASS_VFIXUPIMMPS, + XED_ICLASS_VFIXUPIMMSD, + XED_ICLASS_VFIXUPIMMSS, + XED_ICLASS_VFMADD132PD, + XED_ICLASS_VFMADD132PS, + XED_ICLASS_VFMADD132SD, + XED_ICLASS_VFMADD132SS, + XED_ICLASS_VFMADD213PD, + XED_ICLASS_VFMADD213PS, + XED_ICLASS_VFMADD213SD, + XED_ICLASS_VFMADD213SS, + XED_ICLASS_VFMADD231PD, + XED_ICLASS_VFMADD231PS, + XED_ICLASS_VFMADD231SD, + XED_ICLASS_VFMADD231SS, + XED_ICLASS_VFMADDPD, + XED_ICLASS_VFMADDPS, + XED_ICLASS_VFMADDSD, + XED_ICLASS_VFMADDSS, + XED_ICLASS_VFMADDSUB132PD, + XED_ICLASS_VFMADDSUB132PS, + XED_ICLASS_VFMADDSUB213PD, + XED_ICLASS_VFMADDSUB213PS, + XED_ICLASS_VFMADDSUB231PD, + XED_ICLASS_VFMADDSUB231PS, + XED_ICLASS_VFMADDSUBPD, + XED_ICLASS_VFMADDSUBPS, + XED_ICLASS_VFMSUB132PD, + XED_ICLASS_VFMSUB132PS, + XED_ICLASS_VFMSUB132SD, + XED_ICLASS_VFMSUB132SS, + XED_ICLASS_VFMSUB213PD, + XED_ICLASS_VFMSUB213PS, + XED_ICLASS_VFMSUB213SD, + XED_ICLASS_VFMSUB213SS, + XED_ICLASS_VFMSUB231PD, + XED_ICLASS_VFMSUB231PS, + XED_ICLASS_VFMSUB231SD, + XED_ICLASS_VFMSUB231SS, + XED_ICLASS_VFMSUBADD132PD, + XED_ICLASS_VFMSUBADD132PS, + XED_ICLASS_VFMSUBADD213PD, + XED_ICLASS_VFMSUBADD213PS, + XED_ICLASS_VFMSUBADD231PD, + XED_ICLASS_VFMSUBADD231PS, + XED_ICLASS_VFMSUBADDPD, + XED_ICLASS_VFMSUBADDPS, + XED_ICLASS_VFMSUBPD, + XED_ICLASS_VFMSUBPS, + XED_ICLASS_VFMSUBSD, + XED_ICLASS_VFMSUBSS, + XED_ICLASS_VFNMADD132PD, + XED_ICLASS_VFNMADD132PS, + XED_ICLASS_VFNMADD132SD, + XED_ICLASS_VFNMADD132SS, + XED_ICLASS_VFNMADD213PD, + XED_ICLASS_VFNMADD213PS, + XED_ICLASS_VFNMADD213SD, + XED_ICLASS_VFNMADD213SS, + XED_ICLASS_VFNMADD231PD, + XED_ICLASS_VFNMADD231PS, + XED_ICLASS_VFNMADD231SD, + XED_ICLASS_VFNMADD231SS, + XED_ICLASS_VFNMADDPD, + XED_ICLASS_VFNMADDPS, + XED_ICLASS_VFNMADDSD, + XED_ICLASS_VFNMADDSS, + XED_ICLASS_VFNMSUB132PD, + XED_ICLASS_VFNMSUB132PS, + XED_ICLASS_VFNMSUB132SD, + XED_ICLASS_VFNMSUB132SS, + XED_ICLASS_VFNMSUB213PD, + XED_ICLASS_VFNMSUB213PS, + XED_ICLASS_VFNMSUB213SD, + XED_ICLASS_VFNMSUB213SS, + XED_ICLASS_VFNMSUB231PD, + XED_ICLASS_VFNMSUB231PS, + XED_ICLASS_VFNMSUB231SD, + XED_ICLASS_VFNMSUB231SS, + XED_ICLASS_VFNMSUBPD, + XED_ICLASS_VFNMSUBPS, + XED_ICLASS_VFNMSUBSD, + XED_ICLASS_VFNMSUBSS, + XED_ICLASS_VFPCLASSPD, + XED_ICLASS_VFPCLASSPS, + XED_ICLASS_VFPCLASSSD, + XED_ICLASS_VFPCLASSSS, + XED_ICLASS_VFRCZPD, + XED_ICLASS_VFRCZPS, + XED_ICLASS_VFRCZSD, + XED_ICLASS_VFRCZSS, + XED_ICLASS_VGATHERDPD, + XED_ICLASS_VGATHERDPS, + XED_ICLASS_VGATHERPF0DPD, + XED_ICLASS_VGATHERPF0DPS, + XED_ICLASS_VGATHERPF0QPD, + XED_ICLASS_VGATHERPF0QPS, + XED_ICLASS_VGATHERPF1DPD, + XED_ICLASS_VGATHERPF1DPS, + XED_ICLASS_VGATHERPF1QPD, + XED_ICLASS_VGATHERPF1QPS, + XED_ICLASS_VGATHERQPD, + XED_ICLASS_VGATHERQPS, + XED_ICLASS_VGETEXPPD, + XED_ICLASS_VGETEXPPS, + XED_ICLASS_VGETEXPSD, + XED_ICLASS_VGETEXPSS, + XED_ICLASS_VGETMANTPD, + XED_ICLASS_VGETMANTPS, + XED_ICLASS_VGETMANTSD, + XED_ICLASS_VGETMANTSS, + XED_ICLASS_VHADDPD, + XED_ICLASS_VHADDPS, + XED_ICLASS_VHSUBPD, + XED_ICLASS_VHSUBPS, + XED_ICLASS_VINSERTF128, + XED_ICLASS_VINSERTF32X4, + XED_ICLASS_VINSERTF32X8, + XED_ICLASS_VINSERTF64X2, + XED_ICLASS_VINSERTF64X4, + XED_ICLASS_VINSERTI128, + XED_ICLASS_VINSERTI32X4, + XED_ICLASS_VINSERTI32X8, + XED_ICLASS_VINSERTI64X2, + XED_ICLASS_VINSERTI64X4, + XED_ICLASS_VINSERTPS, + XED_ICLASS_VLDDQU, + XED_ICLASS_VLDMXCSR, + XED_ICLASS_VMASKMOVDQU, + XED_ICLASS_VMASKMOVPD, + XED_ICLASS_VMASKMOVPS, + XED_ICLASS_VMAXPD, + XED_ICLASS_VMAXPS, + XED_ICLASS_VMAXSD, + XED_ICLASS_VMAXSS, + XED_ICLASS_VMCALL, + XED_ICLASS_VMCLEAR, + XED_ICLASS_VMFUNC, + XED_ICLASS_VMINPD, + XED_ICLASS_VMINPS, + XED_ICLASS_VMINSD, + XED_ICLASS_VMINSS, + XED_ICLASS_VMLAUNCH, + XED_ICLASS_VMLOAD, + XED_ICLASS_VMMCALL, + XED_ICLASS_VMOVAPD, + XED_ICLASS_VMOVAPS, + XED_ICLASS_VMOVD, + XED_ICLASS_VMOVDDUP, + XED_ICLASS_VMOVDQA, + XED_ICLASS_VMOVDQA32, + XED_ICLASS_VMOVDQA64, + XED_ICLASS_VMOVDQU, + XED_ICLASS_VMOVDQU16, + XED_ICLASS_VMOVDQU32, + XED_ICLASS_VMOVDQU64, + XED_ICLASS_VMOVDQU8, + XED_ICLASS_VMOVHLPS, + XED_ICLASS_VMOVHPD, + XED_ICLASS_VMOVHPS, + XED_ICLASS_VMOVLHPS, + XED_ICLASS_VMOVLPD, + XED_ICLASS_VMOVLPS, + XED_ICLASS_VMOVMSKPD, + XED_ICLASS_VMOVMSKPS, + XED_ICLASS_VMOVNTDQ, + XED_ICLASS_VMOVNTDQA, + XED_ICLASS_VMOVNTPD, + XED_ICLASS_VMOVNTPS, + XED_ICLASS_VMOVQ, + XED_ICLASS_VMOVSD, + XED_ICLASS_VMOVSHDUP, + XED_ICLASS_VMOVSLDUP, + XED_ICLASS_VMOVSS, + XED_ICLASS_VMOVUPD, + XED_ICLASS_VMOVUPS, + XED_ICLASS_VMPSADBW, + XED_ICLASS_VMPTRLD, + XED_ICLASS_VMPTRST, + XED_ICLASS_VMREAD, + XED_ICLASS_VMRESUME, + XED_ICLASS_VMRUN, + XED_ICLASS_VMSAVE, + XED_ICLASS_VMULPD, + XED_ICLASS_VMULPS, + XED_ICLASS_VMULSD, + XED_ICLASS_VMULSS, + XED_ICLASS_VMWRITE, + XED_ICLASS_VMXOFF, + XED_ICLASS_VMXON, + XED_ICLASS_VORPD, + XED_ICLASS_VORPS, + XED_ICLASS_VPABSB, + XED_ICLASS_VPABSD, + XED_ICLASS_VPABSQ, + XED_ICLASS_VPABSW, + XED_ICLASS_VPACKSSDW, + XED_ICLASS_VPACKSSWB, + XED_ICLASS_VPACKUSDW, + XED_ICLASS_VPACKUSWB, + XED_ICLASS_VPADDB, + XED_ICLASS_VPADDD, + XED_ICLASS_VPADDQ, + XED_ICLASS_VPADDSB, + XED_ICLASS_VPADDSW, + XED_ICLASS_VPADDUSB, + XED_ICLASS_VPADDUSW, + XED_ICLASS_VPADDW, + XED_ICLASS_VPALIGNR, + XED_ICLASS_VPAND, + XED_ICLASS_VPANDD, + XED_ICLASS_VPANDN, + XED_ICLASS_VPANDND, + XED_ICLASS_VPANDNQ, + XED_ICLASS_VPANDQ, + XED_ICLASS_VPAVGB, + XED_ICLASS_VPAVGW, + XED_ICLASS_VPBLENDD, + XED_ICLASS_VPBLENDMB, + XED_ICLASS_VPBLENDMD, + XED_ICLASS_VPBLENDMQ, + XED_ICLASS_VPBLENDMW, + XED_ICLASS_VPBLENDVB, + XED_ICLASS_VPBLENDW, + XED_ICLASS_VPBROADCASTB, + XED_ICLASS_VPBROADCASTD, + XED_ICLASS_VPBROADCASTMB2Q, + XED_ICLASS_VPBROADCASTMW2D, + XED_ICLASS_VPBROADCASTQ, + XED_ICLASS_VPBROADCASTW, + XED_ICLASS_VPCLMULQDQ, + XED_ICLASS_VPCMOV, + XED_ICLASS_VPCMPB, + XED_ICLASS_VPCMPD, + XED_ICLASS_VPCMPEQB, + XED_ICLASS_VPCMPEQD, + XED_ICLASS_VPCMPEQQ, + XED_ICLASS_VPCMPEQW, + XED_ICLASS_VPCMPESTRI, + XED_ICLASS_VPCMPESTRM, + XED_ICLASS_VPCMPGTB, + XED_ICLASS_VPCMPGTD, + XED_ICLASS_VPCMPGTQ, + XED_ICLASS_VPCMPGTW, + XED_ICLASS_VPCMPISTRI, + XED_ICLASS_VPCMPISTRM, + XED_ICLASS_VPCMPQ, + XED_ICLASS_VPCMPUB, + XED_ICLASS_VPCMPUD, + XED_ICLASS_VPCMPUQ, + XED_ICLASS_VPCMPUW, + XED_ICLASS_VPCMPW, + XED_ICLASS_VPCOMB, + XED_ICLASS_VPCOMD, + XED_ICLASS_VPCOMPRESSD, + XED_ICLASS_VPCOMPRESSQ, + XED_ICLASS_VPCOMQ, + XED_ICLASS_VPCOMUB, + XED_ICLASS_VPCOMUD, + XED_ICLASS_VPCOMUQ, + XED_ICLASS_VPCOMUW, + XED_ICLASS_VPCOMW, + XED_ICLASS_VPCONFLICTD, + XED_ICLASS_VPCONFLICTQ, + XED_ICLASS_VPERM2F128, + XED_ICLASS_VPERM2I128, + XED_ICLASS_VPERMB, + XED_ICLASS_VPERMD, + XED_ICLASS_VPERMI2B, + XED_ICLASS_VPERMI2D, + XED_ICLASS_VPERMI2PD, + XED_ICLASS_VPERMI2PS, + XED_ICLASS_VPERMI2Q, + XED_ICLASS_VPERMI2W, + XED_ICLASS_VPERMIL2PD, + XED_ICLASS_VPERMIL2PS, + XED_ICLASS_VPERMILPD, + XED_ICLASS_VPERMILPS, + XED_ICLASS_VPERMPD, + XED_ICLASS_VPERMPS, + XED_ICLASS_VPERMQ, + XED_ICLASS_VPERMT2B, + XED_ICLASS_VPERMT2D, + XED_ICLASS_VPERMT2PD, + XED_ICLASS_VPERMT2PS, + XED_ICLASS_VPERMT2Q, + XED_ICLASS_VPERMT2W, + XED_ICLASS_VPERMW, + XED_ICLASS_VPEXPANDD, + XED_ICLASS_VPEXPANDQ, + XED_ICLASS_VPEXTRB, + XED_ICLASS_VPEXTRD, + XED_ICLASS_VPEXTRQ, + XED_ICLASS_VPEXTRW, + XED_ICLASS_VPGATHERDD, + XED_ICLASS_VPGATHERDQ, + XED_ICLASS_VPGATHERQD, + XED_ICLASS_VPGATHERQQ, + XED_ICLASS_VPHADDBD, + XED_ICLASS_VPHADDBQ, + XED_ICLASS_VPHADDBW, + XED_ICLASS_VPHADDD, + XED_ICLASS_VPHADDDQ, + XED_ICLASS_VPHADDSW, + XED_ICLASS_VPHADDUBD, + XED_ICLASS_VPHADDUBQ, + XED_ICLASS_VPHADDUBW, + XED_ICLASS_VPHADDUDQ, + XED_ICLASS_VPHADDUWD, + XED_ICLASS_VPHADDUWQ, + XED_ICLASS_VPHADDW, + XED_ICLASS_VPHADDWD, + XED_ICLASS_VPHADDWQ, + XED_ICLASS_VPHMINPOSUW, + XED_ICLASS_VPHSUBBW, + XED_ICLASS_VPHSUBD, + XED_ICLASS_VPHSUBDQ, + XED_ICLASS_VPHSUBSW, + XED_ICLASS_VPHSUBW, + XED_ICLASS_VPHSUBWD, + XED_ICLASS_VPINSRB, + XED_ICLASS_VPINSRD, + XED_ICLASS_VPINSRQ, + XED_ICLASS_VPINSRW, + XED_ICLASS_VPLZCNTD, + XED_ICLASS_VPLZCNTQ, + XED_ICLASS_VPMACSDD, + XED_ICLASS_VPMACSDQH, + XED_ICLASS_VPMACSDQL, + XED_ICLASS_VPMACSSDD, + XED_ICLASS_VPMACSSDQH, + XED_ICLASS_VPMACSSDQL, + XED_ICLASS_VPMACSSWD, + XED_ICLASS_VPMACSSWW, + XED_ICLASS_VPMACSWD, + XED_ICLASS_VPMACSWW, + XED_ICLASS_VPMADCSSWD, + XED_ICLASS_VPMADCSWD, + XED_ICLASS_VPMADD52HUQ, + XED_ICLASS_VPMADD52LUQ, + XED_ICLASS_VPMADDUBSW, + XED_ICLASS_VPMADDWD, + XED_ICLASS_VPMASKMOVD, + XED_ICLASS_VPMASKMOVQ, + XED_ICLASS_VPMAXSB, + XED_ICLASS_VPMAXSD, + XED_ICLASS_VPMAXSQ, + XED_ICLASS_VPMAXSW, + XED_ICLASS_VPMAXUB, + XED_ICLASS_VPMAXUD, + XED_ICLASS_VPMAXUQ, + XED_ICLASS_VPMAXUW, + XED_ICLASS_VPMINSB, + XED_ICLASS_VPMINSD, + XED_ICLASS_VPMINSQ, + XED_ICLASS_VPMINSW, + XED_ICLASS_VPMINUB, + XED_ICLASS_VPMINUD, + XED_ICLASS_VPMINUQ, + XED_ICLASS_VPMINUW, + XED_ICLASS_VPMOVB2M, + XED_ICLASS_VPMOVD2M, + XED_ICLASS_VPMOVDB, + XED_ICLASS_VPMOVDW, + XED_ICLASS_VPMOVM2B, + XED_ICLASS_VPMOVM2D, + XED_ICLASS_VPMOVM2Q, + XED_ICLASS_VPMOVM2W, + XED_ICLASS_VPMOVMSKB, + XED_ICLASS_VPMOVQ2M, + XED_ICLASS_VPMOVQB, + XED_ICLASS_VPMOVQD, + XED_ICLASS_VPMOVQW, + XED_ICLASS_VPMOVSDB, + XED_ICLASS_VPMOVSDW, + XED_ICLASS_VPMOVSQB, + XED_ICLASS_VPMOVSQD, + XED_ICLASS_VPMOVSQW, + XED_ICLASS_VPMOVSWB, + XED_ICLASS_VPMOVSXBD, + XED_ICLASS_VPMOVSXBQ, + XED_ICLASS_VPMOVSXBW, + XED_ICLASS_VPMOVSXDQ, + XED_ICLASS_VPMOVSXWD, + XED_ICLASS_VPMOVSXWQ, + XED_ICLASS_VPMOVUSDB, + XED_ICLASS_VPMOVUSDW, + XED_ICLASS_VPMOVUSQB, + XED_ICLASS_VPMOVUSQD, + XED_ICLASS_VPMOVUSQW, + XED_ICLASS_VPMOVUSWB, + XED_ICLASS_VPMOVW2M, + XED_ICLASS_VPMOVWB, + XED_ICLASS_VPMOVZXBD, + XED_ICLASS_VPMOVZXBQ, + XED_ICLASS_VPMOVZXBW, + XED_ICLASS_VPMOVZXDQ, + XED_ICLASS_VPMOVZXWD, + XED_ICLASS_VPMOVZXWQ, + XED_ICLASS_VPMULDQ, + XED_ICLASS_VPMULHRSW, + XED_ICLASS_VPMULHUW, + XED_ICLASS_VPMULHW, + XED_ICLASS_VPMULLD, + XED_ICLASS_VPMULLQ, + XED_ICLASS_VPMULLW, + XED_ICLASS_VPMULTISHIFTQB, + XED_ICLASS_VPMULUDQ, + XED_ICLASS_VPOR, + XED_ICLASS_VPORD, + XED_ICLASS_VPORQ, + XED_ICLASS_VPPERM, + XED_ICLASS_VPROLD, + XED_ICLASS_VPROLQ, + XED_ICLASS_VPROLVD, + XED_ICLASS_VPROLVQ, + XED_ICLASS_VPRORD, + XED_ICLASS_VPRORQ, + XED_ICLASS_VPRORVD, + XED_ICLASS_VPRORVQ, + XED_ICLASS_VPROTB, + XED_ICLASS_VPROTD, + XED_ICLASS_VPROTQ, + XED_ICLASS_VPROTW, + XED_ICLASS_VPSADBW, + XED_ICLASS_VPSCATTERDD, + XED_ICLASS_VPSCATTERDQ, + XED_ICLASS_VPSCATTERQD, + XED_ICLASS_VPSCATTERQQ, + XED_ICLASS_VPSHAB, + XED_ICLASS_VPSHAD, + XED_ICLASS_VPSHAQ, + XED_ICLASS_VPSHAW, + XED_ICLASS_VPSHLB, + XED_ICLASS_VPSHLD, + XED_ICLASS_VPSHLQ, + XED_ICLASS_VPSHLW, + XED_ICLASS_VPSHUFB, + XED_ICLASS_VPSHUFD, + XED_ICLASS_VPSHUFHW, + XED_ICLASS_VPSHUFLW, + XED_ICLASS_VPSIGNB, + XED_ICLASS_VPSIGND, + XED_ICLASS_VPSIGNW, + XED_ICLASS_VPSLLD, + XED_ICLASS_VPSLLDQ, + XED_ICLASS_VPSLLQ, + XED_ICLASS_VPSLLVD, + XED_ICLASS_VPSLLVQ, + XED_ICLASS_VPSLLVW, + XED_ICLASS_VPSLLW, + XED_ICLASS_VPSRAD, + XED_ICLASS_VPSRAQ, + XED_ICLASS_VPSRAVD, + XED_ICLASS_VPSRAVQ, + XED_ICLASS_VPSRAVW, + XED_ICLASS_VPSRAW, + XED_ICLASS_VPSRLD, + XED_ICLASS_VPSRLDQ, + XED_ICLASS_VPSRLQ, + XED_ICLASS_VPSRLVD, + XED_ICLASS_VPSRLVQ, + XED_ICLASS_VPSRLVW, + XED_ICLASS_VPSRLW, + XED_ICLASS_VPSUBB, + XED_ICLASS_VPSUBD, + XED_ICLASS_VPSUBQ, + XED_ICLASS_VPSUBSB, + XED_ICLASS_VPSUBSW, + XED_ICLASS_VPSUBUSB, + XED_ICLASS_VPSUBUSW, + XED_ICLASS_VPSUBW, + XED_ICLASS_VPTERNLOGD, + XED_ICLASS_VPTERNLOGQ, + XED_ICLASS_VPTEST, + XED_ICLASS_VPTESTMB, + XED_ICLASS_VPTESTMD, + XED_ICLASS_VPTESTMQ, + XED_ICLASS_VPTESTMW, + XED_ICLASS_VPTESTNMB, + XED_ICLASS_VPTESTNMD, + XED_ICLASS_VPTESTNMQ, + XED_ICLASS_VPTESTNMW, + XED_ICLASS_VPUNPCKHBW, + XED_ICLASS_VPUNPCKHDQ, + XED_ICLASS_VPUNPCKHQDQ, + XED_ICLASS_VPUNPCKHWD, + XED_ICLASS_VPUNPCKLBW, + XED_ICLASS_VPUNPCKLDQ, + XED_ICLASS_VPUNPCKLQDQ, + XED_ICLASS_VPUNPCKLWD, + XED_ICLASS_VPXOR, + XED_ICLASS_VPXORD, + XED_ICLASS_VPXORQ, + XED_ICLASS_VRANGEPD, + XED_ICLASS_VRANGEPS, + XED_ICLASS_VRANGESD, + XED_ICLASS_VRANGESS, + XED_ICLASS_VRCP14PD, + XED_ICLASS_VRCP14PS, + XED_ICLASS_VRCP14SD, + XED_ICLASS_VRCP14SS, + XED_ICLASS_VRCP28PD, + XED_ICLASS_VRCP28PS, + XED_ICLASS_VRCP28SD, + XED_ICLASS_VRCP28SS, + XED_ICLASS_VRCPPS, + XED_ICLASS_VRCPSS, + XED_ICLASS_VREDUCEPD, + XED_ICLASS_VREDUCEPS, + XED_ICLASS_VREDUCESD, + XED_ICLASS_VREDUCESS, + XED_ICLASS_VRNDSCALEPD, + XED_ICLASS_VRNDSCALEPS, + XED_ICLASS_VRNDSCALESD, + XED_ICLASS_VRNDSCALESS, + XED_ICLASS_VROUNDPD, + XED_ICLASS_VROUNDPS, + XED_ICLASS_VROUNDSD, + XED_ICLASS_VROUNDSS, + XED_ICLASS_VRSQRT14PD, + XED_ICLASS_VRSQRT14PS, + XED_ICLASS_VRSQRT14SD, + XED_ICLASS_VRSQRT14SS, + XED_ICLASS_VRSQRT28PD, + XED_ICLASS_VRSQRT28PS, + XED_ICLASS_VRSQRT28SD, + XED_ICLASS_VRSQRT28SS, + XED_ICLASS_VRSQRTPS, + XED_ICLASS_VRSQRTSS, + XED_ICLASS_VSCALEFPD, + XED_ICLASS_VSCALEFPS, + XED_ICLASS_VSCALEFSD, + XED_ICLASS_VSCALEFSS, + XED_ICLASS_VSCATTERDPD, + XED_ICLASS_VSCATTERDPS, + XED_ICLASS_VSCATTERPF0DPD, + XED_ICLASS_VSCATTERPF0DPS, + XED_ICLASS_VSCATTERPF0QPD, + XED_ICLASS_VSCATTERPF0QPS, + XED_ICLASS_VSCATTERPF1DPD, + XED_ICLASS_VSCATTERPF1DPS, + XED_ICLASS_VSCATTERPF1QPD, + XED_ICLASS_VSCATTERPF1QPS, + XED_ICLASS_VSCATTERQPD, + XED_ICLASS_VSCATTERQPS, + XED_ICLASS_VSHUFF32X4, + XED_ICLASS_VSHUFF64X2, + XED_ICLASS_VSHUFI32X4, + XED_ICLASS_VSHUFI64X2, + XED_ICLASS_VSHUFPD, + XED_ICLASS_VSHUFPS, + XED_ICLASS_VSQRTPD, + XED_ICLASS_VSQRTPS, + XED_ICLASS_VSQRTSD, + XED_ICLASS_VSQRTSS, + XED_ICLASS_VSTMXCSR, + XED_ICLASS_VSUBPD, + XED_ICLASS_VSUBPS, + XED_ICLASS_VSUBSD, + XED_ICLASS_VSUBSS, + XED_ICLASS_VTESTPD, + XED_ICLASS_VTESTPS, + XED_ICLASS_VUCOMISD, + XED_ICLASS_VUCOMISS, + XED_ICLASS_VUNPCKHPD, + XED_ICLASS_VUNPCKHPS, + XED_ICLASS_VUNPCKLPD, + XED_ICLASS_VUNPCKLPS, + XED_ICLASS_VXORPD, + XED_ICLASS_VXORPS, + XED_ICLASS_VZEROALL, + XED_ICLASS_VZEROUPPER, + XED_ICLASS_WBINVD, + XED_ICLASS_WRFSBASE, + XED_ICLASS_WRGSBASE, + XED_ICLASS_WRMSR, + XED_ICLASS_XABORT, + XED_ICLASS_XADD, + XED_ICLASS_XADD_LOCK, + XED_ICLASS_XBEGIN, + XED_ICLASS_XCHG, + XED_ICLASS_XEND, + XED_ICLASS_XGETBV, + XED_ICLASS_XLAT, + XED_ICLASS_XOR, + XED_ICLASS_XORPD, + XED_ICLASS_XORPS, + XED_ICLASS_XOR_LOCK, + XED_ICLASS_XRSTOR, + XED_ICLASS_XRSTOR64, + XED_ICLASS_XRSTORS, + XED_ICLASS_XRSTORS64, + XED_ICLASS_XSAVE, + XED_ICLASS_XSAVE64, + XED_ICLASS_XSAVEC, + XED_ICLASS_XSAVEC64, + XED_ICLASS_XSAVEOPT, + XED_ICLASS_XSAVEOPT64, + XED_ICLASS_XSAVES, + XED_ICLASS_XSAVES64, + XED_ICLASS_XSETBV, + XED_ICLASS_XTEST, + XED_ICLASS_LAST +} xed_iclass_enum_t; + +/// This converts strings to #xed_iclass_enum_t types. +/// @param s A C-string. +/// @return #xed_iclass_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_iclass_enum_t str2xed_iclass_enum_t(const char* s); +/// This converts strings to #xed_iclass_enum_t types. +/// @param p An enumeration element of type xed_iclass_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_iclass_enum_t2str(const xed_iclass_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_iclass_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_iclass_enum_t xed_iclass_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-iform-enum.h b/third_party/xed-intel64/include/xed-iform-enum.h new file mode 100644 index 0000000..3d92cba --- /dev/null +++ b/third_party/xed-intel64/include/xed-iform-enum.h @@ -0,0 +1,6058 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-iform-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_IFORM_ENUM_H_) +# define _XED_IFORM_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" +typedef enum { + XED_IFORM_INVALID=0, + XED_IFORM_AAA=1, + XED_IFORM_AAD_IMMb=2, + XED_IFORM_AAM_IMMb=3, + XED_IFORM_AAS=4, + XED_IFORM_ADC_AL_IMMb=5, + XED_IFORM_ADC_GPR8_GPR8_10=6, + XED_IFORM_ADC_GPR8_GPR8_12=7, + XED_IFORM_ADC_GPR8_IMMb_80r2=8, + XED_IFORM_ADC_GPR8_IMMb_82r2=9, + XED_IFORM_ADC_GPR8_MEMb=10, + XED_IFORM_ADC_GPRv_GPRv_11=11, + XED_IFORM_ADC_GPRv_GPRv_13=12, + XED_IFORM_ADC_GPRv_IMMb=13, + XED_IFORM_ADC_GPRv_IMMz=14, + XED_IFORM_ADC_GPRv_MEMv=15, + XED_IFORM_ADC_MEMb_GPR8=16, + XED_IFORM_ADC_MEMb_IMMb_80r2=17, + XED_IFORM_ADC_MEMb_IMMb_82r2=18, + XED_IFORM_ADC_MEMv_GPRv=19, + XED_IFORM_ADC_MEMv_IMMb=20, + XED_IFORM_ADC_MEMv_IMMz=21, + XED_IFORM_ADC_OrAX_IMMz=22, + XED_IFORM_ADCX_GPR32d_GPR32d=23, + XED_IFORM_ADCX_GPR32d_MEMd=24, + XED_IFORM_ADCX_GPR64q_GPR64q=25, + XED_IFORM_ADCX_GPR64q_MEMq=26, + XED_IFORM_ADC_LOCK_MEMb_GPR8=27, + XED_IFORM_ADC_LOCK_MEMb_IMMb_80r2=28, + XED_IFORM_ADC_LOCK_MEMb_IMMb_82r2=29, + XED_IFORM_ADC_LOCK_MEMv_GPRv=30, + XED_IFORM_ADC_LOCK_MEMv_IMMb=31, + XED_IFORM_ADC_LOCK_MEMv_IMMz=32, + XED_IFORM_ADD_AL_IMMb=33, + XED_IFORM_ADD_GPR8_GPR8_00=34, + XED_IFORM_ADD_GPR8_GPR8_02=35, + XED_IFORM_ADD_GPR8_IMMb_80r0=36, + XED_IFORM_ADD_GPR8_IMMb_82r0=37, + XED_IFORM_ADD_GPR8_MEMb=38, + XED_IFORM_ADD_GPRv_GPRv_01=39, + XED_IFORM_ADD_GPRv_GPRv_03=40, + XED_IFORM_ADD_GPRv_IMMb=41, + XED_IFORM_ADD_GPRv_IMMz=42, + XED_IFORM_ADD_GPRv_MEMv=43, + XED_IFORM_ADD_MEMb_GPR8=44, + XED_IFORM_ADD_MEMb_IMMb_80r0=45, + XED_IFORM_ADD_MEMb_IMMb_82r0=46, + XED_IFORM_ADD_MEMv_GPRv=47, + XED_IFORM_ADD_MEMv_IMMb=48, + XED_IFORM_ADD_MEMv_IMMz=49, + XED_IFORM_ADD_OrAX_IMMz=50, + XED_IFORM_ADDPD_XMMpd_MEMpd=51, + XED_IFORM_ADDPD_XMMpd_XMMpd=52, + XED_IFORM_ADDPS_XMMps_MEMps=53, + XED_IFORM_ADDPS_XMMps_XMMps=54, + XED_IFORM_ADDSD_XMMsd_MEMsd=55, + XED_IFORM_ADDSD_XMMsd_XMMsd=56, + XED_IFORM_ADDSS_XMMss_MEMss=57, + XED_IFORM_ADDSS_XMMss_XMMss=58, + XED_IFORM_ADDSUBPD_XMMpd_MEMpd=59, + XED_IFORM_ADDSUBPD_XMMpd_XMMpd=60, + XED_IFORM_ADDSUBPS_XMMps_MEMps=61, + XED_IFORM_ADDSUBPS_XMMps_XMMps=62, + XED_IFORM_ADD_LOCK_MEMb_GPR8=63, + XED_IFORM_ADD_LOCK_MEMb_IMMb_80r0=64, + XED_IFORM_ADD_LOCK_MEMb_IMMb_82r0=65, + XED_IFORM_ADD_LOCK_MEMv_GPRv=66, + XED_IFORM_ADD_LOCK_MEMv_IMMb=67, + XED_IFORM_ADD_LOCK_MEMv_IMMz=68, + XED_IFORM_ADOX_GPR32d_GPR32d=69, + XED_IFORM_ADOX_GPR32d_MEMd=70, + XED_IFORM_ADOX_GPR64q_GPR64q=71, + XED_IFORM_ADOX_GPR64q_MEMq=72, + XED_IFORM_AESDEC_XMMdq_MEMdq=73, + XED_IFORM_AESDEC_XMMdq_XMMdq=74, + XED_IFORM_AESDECLAST_XMMdq_MEMdq=75, + XED_IFORM_AESDECLAST_XMMdq_XMMdq=76, + XED_IFORM_AESENC_XMMdq_MEMdq=77, + XED_IFORM_AESENC_XMMdq_XMMdq=78, + XED_IFORM_AESENCLAST_XMMdq_MEMdq=79, + XED_IFORM_AESENCLAST_XMMdq_XMMdq=80, + XED_IFORM_AESIMC_XMMdq_MEMdq=81, + XED_IFORM_AESIMC_XMMdq_XMMdq=82, + XED_IFORM_AESKEYGENASSIST_XMMdq_MEMdq_IMMb=83, + XED_IFORM_AESKEYGENASSIST_XMMdq_XMMdq_IMMb=84, + XED_IFORM_AND_AL_IMMb=85, + XED_IFORM_AND_GPR8_GPR8_20=86, + XED_IFORM_AND_GPR8_GPR8_22=87, + XED_IFORM_AND_GPR8_IMMb_80r4=88, + XED_IFORM_AND_GPR8_IMMb_82r4=89, + XED_IFORM_AND_GPR8_MEMb=90, + XED_IFORM_AND_GPRv_GPRv_21=91, + XED_IFORM_AND_GPRv_GPRv_23=92, + XED_IFORM_AND_GPRv_IMMb=93, + XED_IFORM_AND_GPRv_IMMz=94, + XED_IFORM_AND_GPRv_MEMv=95, + XED_IFORM_AND_MEMb_GPR8=96, + XED_IFORM_AND_MEMb_IMMb_80r4=97, + XED_IFORM_AND_MEMb_IMMb_82r4=98, + XED_IFORM_AND_MEMv_GPRv=99, + XED_IFORM_AND_MEMv_IMMb=100, + XED_IFORM_AND_MEMv_IMMz=101, + XED_IFORM_AND_OrAX_IMMz=102, + XED_IFORM_ANDN_VGPR32d_VGPR32d_MEMd=103, + XED_IFORM_ANDN_VGPR32d_VGPR32d_VGPR32d=104, + XED_IFORM_ANDN_VGPR64q_VGPR64q_MEMq=105, + XED_IFORM_ANDN_VGPR64q_VGPR64q_VGPR64q=106, + XED_IFORM_ANDNPD_XMMpd_MEMpd=107, + XED_IFORM_ANDNPD_XMMpd_XMMpd=108, + XED_IFORM_ANDNPS_XMMps_MEMps=109, + XED_IFORM_ANDNPS_XMMps_XMMps=110, + XED_IFORM_ANDPD_XMMpd_MEMpd=111, + XED_IFORM_ANDPD_XMMpd_XMMpd=112, + XED_IFORM_ANDPS_XMMps_MEMps=113, + XED_IFORM_ANDPS_XMMps_XMMps=114, + XED_IFORM_AND_LOCK_MEMb_GPR8=115, + XED_IFORM_AND_LOCK_MEMb_IMMb_80r4=116, + XED_IFORM_AND_LOCK_MEMb_IMMb_82r4=117, + XED_IFORM_AND_LOCK_MEMv_GPRv=118, + XED_IFORM_AND_LOCK_MEMv_IMMb=119, + XED_IFORM_AND_LOCK_MEMv_IMMz=120, + XED_IFORM_ARPL_GPR16_GPR16=121, + XED_IFORM_ARPL_MEMw_GPR16=122, + XED_IFORM_BEXTR_VGPR32d_MEMd_VGPR32d=123, + XED_IFORM_BEXTR_VGPR32d_VGPR32d_VGPR32d=124, + XED_IFORM_BEXTR_VGPR64q_MEMq_VGPR64q=125, + XED_IFORM_BEXTR_VGPR64q_VGPR64q_VGPR64q=126, + XED_IFORM_BEXTR_XOP_GPRyy_GPRyy_IMMd=127, + XED_IFORM_BEXTR_XOP_GPRyy_MEMy_IMMd=128, + XED_IFORM_BLCFILL_GPRyy_GPRvy=129, + XED_IFORM_BLCFILL_GPRyy_MEMy=130, + XED_IFORM_BLCI_GPRyy_GPRvy=131, + XED_IFORM_BLCI_GPRyy_MEMy=132, + XED_IFORM_BLCIC_GPRyy_GPRvy=133, + XED_IFORM_BLCIC_GPRyy_MEMy=134, + XED_IFORM_BLCMSK_GPRyy_GPRvy=135, + XED_IFORM_BLCMSK_GPRyy_MEMy=136, + XED_IFORM_BLCS_GPRyy_GPRvy=137, + XED_IFORM_BLCS_GPRyy_MEMy=138, + XED_IFORM_BLENDPD_XMMdq_MEMdq_IMMb=139, + XED_IFORM_BLENDPD_XMMdq_XMMdq_IMMb=140, + XED_IFORM_BLENDPS_XMMdq_MEMdq_IMMb=141, + XED_IFORM_BLENDPS_XMMdq_XMMdq_IMMb=142, + XED_IFORM_BLENDVPD_XMMdq_MEMdq=143, + XED_IFORM_BLENDVPD_XMMdq_XMMdq=144, + XED_IFORM_BLENDVPS_XMMdq_MEMdq=145, + XED_IFORM_BLENDVPS_XMMdq_XMMdq=146, + XED_IFORM_BLSFILL_GPRyy_GPRvy=147, + XED_IFORM_BLSFILL_GPRyy_MEMy=148, + XED_IFORM_BLSI_VGPR32d_MEMd=149, + XED_IFORM_BLSI_VGPR32d_VGPR32d=150, + XED_IFORM_BLSI_VGPR64q_MEMq=151, + XED_IFORM_BLSI_VGPR64q_VGPR64q=152, + XED_IFORM_BLSIC_GPRyy_GPRvy=153, + XED_IFORM_BLSIC_GPRyy_MEMy=154, + XED_IFORM_BLSMSK_VGPR32d_MEMd=155, + XED_IFORM_BLSMSK_VGPR32d_VGPR32d=156, + XED_IFORM_BLSMSK_VGPR64q_MEMq=157, + XED_IFORM_BLSMSK_VGPR64q_VGPR64q=158, + XED_IFORM_BLSR_VGPR32d_MEMd=159, + XED_IFORM_BLSR_VGPR32d_VGPR32d=160, + XED_IFORM_BLSR_VGPR64q_MEMq=161, + XED_IFORM_BLSR_VGPR64q_VGPR64q=162, + XED_IFORM_BNDCL_BND_AGEN=163, + XED_IFORM_BNDCL_BND_GPR32=164, + XED_IFORM_BNDCL_BND_GPR64=165, + XED_IFORM_BNDCN_BND_AGEN=166, + XED_IFORM_BNDCN_BND_GPR32=167, + XED_IFORM_BNDCN_BND_GPR64=168, + XED_IFORM_BNDCU_BND_AGEN=169, + XED_IFORM_BNDCU_BND_GPR32=170, + XED_IFORM_BNDCU_BND_GPR64=171, + XED_IFORM_BNDLDX_BND_MEMbnd32=172, + XED_IFORM_BNDLDX_BND_MEMbnd64=173, + XED_IFORM_BNDMK_BND_AGEN=174, + XED_IFORM_BNDMOV_BND_BND=175, + XED_IFORM_BNDMOV_BND_MEMdq=176, + XED_IFORM_BNDMOV_BND_MEMq=177, + XED_IFORM_BNDMOV_MEMdq_BND=178, + XED_IFORM_BNDMOV_MEMq_BND=179, + XED_IFORM_BNDSTX_MEMbnd32_BND=180, + XED_IFORM_BNDSTX_MEMbnd64_BND=181, + XED_IFORM_BOUND_GPRv_MEMa16=182, + XED_IFORM_BOUND_GPRv_MEMa32=183, + XED_IFORM_BSF_GPRv_GPRv=184, + XED_IFORM_BSF_GPRv_MEMv=185, + XED_IFORM_BSR_GPRv_GPRv=186, + XED_IFORM_BSR_GPRv_MEMv=187, + XED_IFORM_BSWAP_GPRv=188, + XED_IFORM_BT_GPRv_GPRv=189, + XED_IFORM_BT_GPRv_IMMb=190, + XED_IFORM_BT_MEMv_GPRv=191, + XED_IFORM_BT_MEMv_IMMb=192, + XED_IFORM_BTC_GPRv_GPRv=193, + XED_IFORM_BTC_GPRv_IMMb=194, + XED_IFORM_BTC_MEMv_GPRv=195, + XED_IFORM_BTC_MEMv_IMMb=196, + XED_IFORM_BTC_LOCK_MEMv_GPRv=197, + XED_IFORM_BTC_LOCK_MEMv_IMMb=198, + XED_IFORM_BTR_GPRv_GPRv=199, + XED_IFORM_BTR_GPRv_IMMb=200, + XED_IFORM_BTR_MEMv_GPRv=201, + XED_IFORM_BTR_MEMv_IMMb=202, + XED_IFORM_BTR_LOCK_MEMv_GPRv=203, + XED_IFORM_BTR_LOCK_MEMv_IMMb=204, + XED_IFORM_BTS_GPRv_GPRv=205, + XED_IFORM_BTS_GPRv_IMMb=206, + XED_IFORM_BTS_MEMv_GPRv=207, + XED_IFORM_BTS_MEMv_IMMb=208, + XED_IFORM_BTS_LOCK_MEMv_GPRv=209, + XED_IFORM_BTS_LOCK_MEMv_IMMb=210, + XED_IFORM_BZHI_VGPR32d_MEMd_VGPR32d=211, + XED_IFORM_BZHI_VGPR32d_VGPR32d_VGPR32d=212, + XED_IFORM_BZHI_VGPR64q_MEMq_VGPR64q=213, + XED_IFORM_BZHI_VGPR64q_VGPR64q_VGPR64q=214, + XED_IFORM_CALL_FAR_MEMp2=215, + XED_IFORM_CALL_FAR_PTRp_IMMw=216, + XED_IFORM_CALL_NEAR_GPRv=217, + XED_IFORM_CALL_NEAR_MEMv=218, + XED_IFORM_CALL_NEAR_RELBRd=219, + XED_IFORM_CALL_NEAR_RELBRz=220, + XED_IFORM_CBW=221, + XED_IFORM_CDQ=222, + XED_IFORM_CDQE=223, + XED_IFORM_CLAC=224, + XED_IFORM_CLC=225, + XED_IFORM_CLD=226, + XED_IFORM_CLFLUSH_MEMmprefetch=227, + XED_IFORM_CLFLUSHOPT_MEMmprefetch=228, + XED_IFORM_CLGI=229, + XED_IFORM_CLI=230, + XED_IFORM_CLTS=231, + XED_IFORM_CLWB_MEMmprefetch=232, + XED_IFORM_CMC=233, + XED_IFORM_CMOVB_GPRv_GPRv=234, + XED_IFORM_CMOVB_GPRv_MEMv=235, + XED_IFORM_CMOVBE_GPRv_GPRv=236, + XED_IFORM_CMOVBE_GPRv_MEMv=237, + XED_IFORM_CMOVL_GPRv_GPRv=238, + XED_IFORM_CMOVL_GPRv_MEMv=239, + XED_IFORM_CMOVLE_GPRv_GPRv=240, + XED_IFORM_CMOVLE_GPRv_MEMv=241, + XED_IFORM_CMOVNB_GPRv_GPRv=242, + XED_IFORM_CMOVNB_GPRv_MEMv=243, + XED_IFORM_CMOVNBE_GPRv_GPRv=244, + XED_IFORM_CMOVNBE_GPRv_MEMv=245, + XED_IFORM_CMOVNL_GPRv_GPRv=246, + XED_IFORM_CMOVNL_GPRv_MEMv=247, + XED_IFORM_CMOVNLE_GPRv_GPRv=248, + XED_IFORM_CMOVNLE_GPRv_MEMv=249, + XED_IFORM_CMOVNO_GPRv_GPRv=250, + XED_IFORM_CMOVNO_GPRv_MEMv=251, + XED_IFORM_CMOVNP_GPRv_GPRv=252, + XED_IFORM_CMOVNP_GPRv_MEMv=253, + XED_IFORM_CMOVNS_GPRv_GPRv=254, + XED_IFORM_CMOVNS_GPRv_MEMv=255, + XED_IFORM_CMOVNZ_GPRv_GPRv=256, + XED_IFORM_CMOVNZ_GPRv_MEMv=257, + XED_IFORM_CMOVO_GPRv_GPRv=258, + XED_IFORM_CMOVO_GPRv_MEMv=259, + XED_IFORM_CMOVP_GPRv_GPRv=260, + XED_IFORM_CMOVP_GPRv_MEMv=261, + XED_IFORM_CMOVS_GPRv_GPRv=262, + XED_IFORM_CMOVS_GPRv_MEMv=263, + XED_IFORM_CMOVZ_GPRv_GPRv=264, + XED_IFORM_CMOVZ_GPRv_MEMv=265, + XED_IFORM_CMP_AL_IMMb=266, + XED_IFORM_CMP_GPR8_GPR8_38=267, + XED_IFORM_CMP_GPR8_GPR8_3A=268, + XED_IFORM_CMP_GPR8_IMMb_80r7=269, + XED_IFORM_CMP_GPR8_IMMb_82r7=270, + XED_IFORM_CMP_GPR8_MEMb=271, + XED_IFORM_CMP_GPRv_GPRv_39=272, + XED_IFORM_CMP_GPRv_GPRv_3B=273, + XED_IFORM_CMP_GPRv_IMMb=274, + XED_IFORM_CMP_GPRv_IMMz=275, + XED_IFORM_CMP_GPRv_MEMv=276, + XED_IFORM_CMP_MEMb_GPR8=277, + XED_IFORM_CMP_MEMb_IMMb_80r7=278, + XED_IFORM_CMP_MEMb_IMMb_82r7=279, + XED_IFORM_CMP_MEMv_GPRv=280, + XED_IFORM_CMP_MEMv_IMMb=281, + XED_IFORM_CMP_MEMv_IMMz=282, + XED_IFORM_CMP_OrAX_IMMz=283, + XED_IFORM_CMPPD_XMMpd_MEMpd_IMMb=284, + XED_IFORM_CMPPD_XMMpd_XMMpd_IMMb=285, + XED_IFORM_CMPPS_XMMps_MEMps_IMMb=286, + XED_IFORM_CMPPS_XMMps_XMMps_IMMb=287, + XED_IFORM_CMPSB=288, + XED_IFORM_CMPSD=289, + XED_IFORM_CMPSD_XMM_XMMsd_MEMsd_IMMb=290, + XED_IFORM_CMPSD_XMM_XMMsd_XMMsd_IMMb=291, + XED_IFORM_CMPSQ=292, + XED_IFORM_CMPSS_XMMss_MEMss_IMMb=293, + XED_IFORM_CMPSS_XMMss_XMMss_IMMb=294, + XED_IFORM_CMPSW=295, + XED_IFORM_CMPXCHG_GPR8_GPR8=296, + XED_IFORM_CMPXCHG_GPRv_GPRv=297, + XED_IFORM_CMPXCHG_MEMb_GPR8=298, + XED_IFORM_CMPXCHG_MEMv_GPRv=299, + XED_IFORM_CMPXCHG16B_MEMdq=300, + XED_IFORM_CMPXCHG16B_LOCK_MEMdq=301, + XED_IFORM_CMPXCHG8B_MEMq=302, + XED_IFORM_CMPXCHG8B_LOCK_MEMq=303, + XED_IFORM_CMPXCHG_LOCK_MEMb_GPR8=304, + XED_IFORM_CMPXCHG_LOCK_MEMv_GPRv=305, + XED_IFORM_COMISD_XMMsd_MEMsd=306, + XED_IFORM_COMISD_XMMsd_XMMsd=307, + XED_IFORM_COMISS_XMMss_MEMss=308, + XED_IFORM_COMISS_XMMss_XMMss=309, + XED_IFORM_CPUID=310, + XED_IFORM_CQO=311, + XED_IFORM_CRC32_GPRyy_GPR8b=312, + XED_IFORM_CRC32_GPRyy_GPRv=313, + XED_IFORM_CRC32_GPRyy_MEMb=314, + XED_IFORM_CRC32_GPRyy_MEMv=315, + XED_IFORM_CVTDQ2PD_XMMpd_MEMq=316, + XED_IFORM_CVTDQ2PD_XMMpd_XMMq=317, + XED_IFORM_CVTDQ2PS_XMMps_MEMdq=318, + XED_IFORM_CVTDQ2PS_XMMps_XMMdq=319, + XED_IFORM_CVTPD2DQ_XMMdq_MEMpd=320, + XED_IFORM_CVTPD2DQ_XMMdq_XMMpd=321, + XED_IFORM_CVTPD2PI_MMXq_MEMpd=322, + XED_IFORM_CVTPD2PI_MMXq_XMMpd=323, + XED_IFORM_CVTPD2PS_XMMps_MEMpd=324, + XED_IFORM_CVTPD2PS_XMMps_XMMpd=325, + XED_IFORM_CVTPI2PD_XMMpd_MEMq=326, + XED_IFORM_CVTPI2PD_XMMpd_MMXq=327, + XED_IFORM_CVTPI2PS_XMMq_MEMq=328, + XED_IFORM_CVTPI2PS_XMMq_MMXq=329, + XED_IFORM_CVTPS2DQ_XMMdq_MEMps=330, + XED_IFORM_CVTPS2DQ_XMMdq_XMMps=331, + XED_IFORM_CVTPS2PD_XMMpd_MEMq=332, + XED_IFORM_CVTPS2PD_XMMpd_XMMq=333, + XED_IFORM_CVTPS2PI_MMXq_MEMq=334, + XED_IFORM_CVTPS2PI_MMXq_XMMq=335, + XED_IFORM_CVTSD2SI_GPR32d_MEMsd=336, + XED_IFORM_CVTSD2SI_GPR32d_XMMsd=337, + XED_IFORM_CVTSD2SI_GPR64q_MEMsd=338, + XED_IFORM_CVTSD2SI_GPR64q_XMMsd=339, + XED_IFORM_CVTSD2SS_XMMss_MEMsd=340, + XED_IFORM_CVTSD2SS_XMMss_XMMsd=341, + XED_IFORM_CVTSI2SD_XMMsd_GPR32d=342, + XED_IFORM_CVTSI2SD_XMMsd_GPR64q=343, + XED_IFORM_CVTSI2SD_XMMsd_MEMd=344, + XED_IFORM_CVTSI2SD_XMMsd_MEMq=345, + XED_IFORM_CVTSI2SS_XMMss_GPR32d=346, + XED_IFORM_CVTSI2SS_XMMss_GPR64q=347, + XED_IFORM_CVTSI2SS_XMMss_MEMd=348, + XED_IFORM_CVTSI2SS_XMMss_MEMq=349, + XED_IFORM_CVTSS2SD_XMMsd_MEMss=350, + XED_IFORM_CVTSS2SD_XMMsd_XMMss=351, + XED_IFORM_CVTSS2SI_GPR32d_MEMss=352, + XED_IFORM_CVTSS2SI_GPR32d_XMMss=353, + XED_IFORM_CVTSS2SI_GPR64q_MEMss=354, + XED_IFORM_CVTSS2SI_GPR64q_XMMss=355, + XED_IFORM_CVTTPD2DQ_XMMdq_MEMpd=356, + XED_IFORM_CVTTPD2DQ_XMMdq_XMMpd=357, + XED_IFORM_CVTTPD2PI_MMXq_MEMpd=358, + XED_IFORM_CVTTPD2PI_MMXq_XMMpd=359, + XED_IFORM_CVTTPS2DQ_XMMdq_MEMps=360, + XED_IFORM_CVTTPS2DQ_XMMdq_XMMps=361, + XED_IFORM_CVTTPS2PI_MMXq_MEMq=362, + XED_IFORM_CVTTPS2PI_MMXq_XMMq=363, + XED_IFORM_CVTTSD2SI_GPR32d_MEMsd=364, + XED_IFORM_CVTTSD2SI_GPR32d_XMMsd=365, + XED_IFORM_CVTTSD2SI_GPR64q_MEMsd=366, + XED_IFORM_CVTTSD2SI_GPR64q_XMMsd=367, + XED_IFORM_CVTTSS2SI_GPR32d_MEMss=368, + XED_IFORM_CVTTSS2SI_GPR32d_XMMss=369, + XED_IFORM_CVTTSS2SI_GPR64q_MEMss=370, + XED_IFORM_CVTTSS2SI_GPR64q_XMMss=371, + XED_IFORM_CWD=372, + XED_IFORM_CWDE=373, + XED_IFORM_DAA=374, + XED_IFORM_DAS=375, + XED_IFORM_DEC_GPR8=376, + XED_IFORM_DEC_GPRv_48=377, + XED_IFORM_DEC_GPRv_FFr1=378, + XED_IFORM_DEC_MEMb=379, + XED_IFORM_DEC_MEMv=380, + XED_IFORM_DEC_LOCK_MEMb=381, + XED_IFORM_DEC_LOCK_MEMv=382, + XED_IFORM_DIV_GPR8=383, + XED_IFORM_DIV_GPRv=384, + XED_IFORM_DIV_MEMb=385, + XED_IFORM_DIV_MEMv=386, + XED_IFORM_DIVPD_XMMpd_MEMpd=387, + XED_IFORM_DIVPD_XMMpd_XMMpd=388, + XED_IFORM_DIVPS_XMMps_MEMps=389, + XED_IFORM_DIVPS_XMMps_XMMps=390, + XED_IFORM_DIVSD_XMMsd_MEMsd=391, + XED_IFORM_DIVSD_XMMsd_XMMsd=392, + XED_IFORM_DIVSS_XMMss_MEMss=393, + XED_IFORM_DIVSS_XMMss_XMMss=394, + XED_IFORM_DPPD_XMMdq_MEMdq_IMMb=395, + XED_IFORM_DPPD_XMMdq_XMMdq_IMMb=396, + XED_IFORM_DPPS_XMMdq_MEMdq_IMMb=397, + XED_IFORM_DPPS_XMMdq_XMMdq_IMMb=398, + XED_IFORM_EMMS=399, + XED_IFORM_ENCLS_EAX_RBX_RCX_RDX=400, + XED_IFORM_ENCLU_EAX_RBX_RCX_RDX=401, + XED_IFORM_ENTER_IMMw_IMMb=402, + XED_IFORM_EXTRACTPS_GPR32d_XMMdq_IMMb=403, + XED_IFORM_EXTRACTPS_MEMd_XMMps_IMMb=404, + XED_IFORM_EXTRQ_XMMq_IMMb_IMMb=405, + XED_IFORM_EXTRQ_XMMq_XMMdq=406, + XED_IFORM_F2XM1_ST0=407, + XED_IFORM_FABS_ST0=408, + XED_IFORM_FADD_ST0_MEMm64real=409, + XED_IFORM_FADD_ST0_MEMmem32real=410, + XED_IFORM_FADD_ST0_X87=411, + XED_IFORM_FADD_X87_ST0=412, + XED_IFORM_FADDP_X87_ST0=413, + XED_IFORM_FBLD_ST0_MEMmem80dec=414, + XED_IFORM_FBSTP_MEMmem80dec_ST0=415, + XED_IFORM_FCHS_ST0=416, + XED_IFORM_FCMOVB_ST0_X87=417, + XED_IFORM_FCMOVBE_ST0_X87=418, + XED_IFORM_FCMOVE_ST0_X87=419, + XED_IFORM_FCMOVNB_ST0_X87=420, + XED_IFORM_FCMOVNBE_ST0_X87=421, + XED_IFORM_FCMOVNE_ST0_X87=422, + XED_IFORM_FCMOVNU_ST0_X87=423, + XED_IFORM_FCMOVU_ST0_X87=424, + XED_IFORM_FCOM_ST0_MEMm64real=425, + XED_IFORM_FCOM_ST0_MEMmem32real=426, + XED_IFORM_FCOM_ST0_X87=427, + XED_IFORM_FCOM_ST0_X87_DCD0=428, + XED_IFORM_FCOMI_ST0_X87=429, + XED_IFORM_FCOMIP_ST0_X87=430, + XED_IFORM_FCOMP_ST0_MEMm64real=431, + XED_IFORM_FCOMP_ST0_MEMmem32real=432, + XED_IFORM_FCOMP_ST0_X87=433, + XED_IFORM_FCOMP_ST0_X87_DCD1=434, + XED_IFORM_FCOMP_ST0_X87_DED0=435, + XED_IFORM_FCOMPP_ST0_ST1=436, + XED_IFORM_FCOS_ST0=437, + XED_IFORM_FDECSTP=438, + XED_IFORM_FDISI8087_NOP=439, + XED_IFORM_FDIV_ST0_MEMm64real=440, + XED_IFORM_FDIV_ST0_MEMmem32real=441, + XED_IFORM_FDIV_ST0_X87=442, + XED_IFORM_FDIV_X87_ST0=443, + XED_IFORM_FDIVP_X87_ST0=444, + XED_IFORM_FDIVR_ST0_MEMm64real=445, + XED_IFORM_FDIVR_ST0_MEMmem32real=446, + XED_IFORM_FDIVR_ST0_X87=447, + XED_IFORM_FDIVR_X87_ST0=448, + XED_IFORM_FDIVRP_X87_ST0=449, + XED_IFORM_FEMMS=450, + XED_IFORM_FENI8087_NOP=451, + XED_IFORM_FFREE_X87=452, + XED_IFORM_FFREEP_X87=453, + XED_IFORM_FIADD_ST0_MEMmem16int=454, + XED_IFORM_FIADD_ST0_MEMmem32int=455, + XED_IFORM_FICOM_ST0_MEMmem16int=456, + XED_IFORM_FICOM_ST0_MEMmem32int=457, + XED_IFORM_FICOMP_ST0_MEMmem16int=458, + XED_IFORM_FICOMP_ST0_MEMmem32int=459, + XED_IFORM_FIDIV_ST0_MEMmem16int=460, + XED_IFORM_FIDIV_ST0_MEMmem32int=461, + XED_IFORM_FIDIVR_ST0_MEMmem16int=462, + XED_IFORM_FIDIVR_ST0_MEMmem32int=463, + XED_IFORM_FILD_ST0_MEMm64int=464, + XED_IFORM_FILD_ST0_MEMmem16int=465, + XED_IFORM_FILD_ST0_MEMmem32int=466, + XED_IFORM_FIMUL_ST0_MEMmem16int=467, + XED_IFORM_FIMUL_ST0_MEMmem32int=468, + XED_IFORM_FINCSTP=469, + XED_IFORM_FIST_MEMmem16int_ST0=470, + XED_IFORM_FIST_MEMmem32int_ST0=471, + XED_IFORM_FISTP_MEMm64int_ST0=472, + XED_IFORM_FISTP_MEMmem16int_ST0=473, + XED_IFORM_FISTP_MEMmem32int_ST0=474, + XED_IFORM_FISTTP_MEMm64int_ST0=475, + XED_IFORM_FISTTP_MEMmem16int_ST0=476, + XED_IFORM_FISTTP_MEMmem32int_ST0=477, + XED_IFORM_FISUB_ST0_MEMmem16int=478, + XED_IFORM_FISUB_ST0_MEMmem32int=479, + XED_IFORM_FISUBR_ST0_MEMmem16int=480, + XED_IFORM_FISUBR_ST0_MEMmem32int=481, + XED_IFORM_FLD_ST0_MEMm64real=482, + XED_IFORM_FLD_ST0_MEMmem32real=483, + XED_IFORM_FLD_ST0_MEMmem80real=484, + XED_IFORM_FLD_ST0_X87=485, + XED_IFORM_FLD1_ST0=486, + XED_IFORM_FLDCW_MEMmem16=487, + XED_IFORM_FLDENV_MEMmem14=488, + XED_IFORM_FLDENV_MEMmem28=489, + XED_IFORM_FLDL2E_ST0=490, + XED_IFORM_FLDL2T_ST0=491, + XED_IFORM_FLDLG2_ST0=492, + XED_IFORM_FLDLN2_ST0=493, + XED_IFORM_FLDPI_ST0=494, + XED_IFORM_FLDZ_ST0=495, + XED_IFORM_FMUL_ST0_MEMm64real=496, + XED_IFORM_FMUL_ST0_MEMmem32real=497, + XED_IFORM_FMUL_ST0_X87=498, + XED_IFORM_FMUL_X87_ST0=499, + XED_IFORM_FMULP_X87_ST0=500, + XED_IFORM_FNCLEX=501, + XED_IFORM_FNINIT=502, + XED_IFORM_FNOP=503, + XED_IFORM_FNSAVE_MEMmem108=504, + XED_IFORM_FNSAVE_MEMmem94=505, + XED_IFORM_FNSTCW_MEMmem16=506, + XED_IFORM_FNSTENV_MEMmem14=507, + XED_IFORM_FNSTENV_MEMmem28=508, + XED_IFORM_FNSTSW_AX=509, + XED_IFORM_FNSTSW_MEMmem16=510, + XED_IFORM_FPATAN_ST0_ST1=511, + XED_IFORM_FPREM_ST0_ST1=512, + XED_IFORM_FPREM1_ST0_ST1=513, + XED_IFORM_FPTAN_ST0_ST1=514, + XED_IFORM_FRNDINT_ST0=515, + XED_IFORM_FRSTOR_MEMmem108=516, + XED_IFORM_FRSTOR_MEMmem94=517, + XED_IFORM_FSCALE_ST0_ST1=518, + XED_IFORM_FSETPM287_NOP=519, + XED_IFORM_FSIN_ST0=520, + XED_IFORM_FSINCOS_ST0_ST1=521, + XED_IFORM_FSQRT_ST0=522, + XED_IFORM_FST_MEMm64real_ST0=523, + XED_IFORM_FST_MEMmem32real_ST0=524, + XED_IFORM_FST_X87_ST0=525, + XED_IFORM_FSTP_MEMm64real_ST0=526, + XED_IFORM_FSTP_MEMmem32real_ST0=527, + XED_IFORM_FSTP_MEMmem80real_ST0=528, + XED_IFORM_FSTP_X87_ST0=529, + XED_IFORM_FSTP_X87_ST0_DFD0=530, + XED_IFORM_FSTP_X87_ST0_DFD1=531, + XED_IFORM_FSTPNCE_X87_ST0=532, + XED_IFORM_FSUB_ST0_MEMm64real=533, + XED_IFORM_FSUB_ST0_MEMmem32real=534, + XED_IFORM_FSUB_ST0_X87=535, + XED_IFORM_FSUB_X87_ST0=536, + XED_IFORM_FSUBP_X87_ST0=537, + XED_IFORM_FSUBR_ST0_MEMm64real=538, + XED_IFORM_FSUBR_ST0_MEMmem32real=539, + XED_IFORM_FSUBR_ST0_X87=540, + XED_IFORM_FSUBR_X87_ST0=541, + XED_IFORM_FSUBRP_X87_ST0=542, + XED_IFORM_FTST_ST0=543, + XED_IFORM_FUCOM_ST0_X87=544, + XED_IFORM_FUCOMI_ST0_X87=545, + XED_IFORM_FUCOMIP_ST0_X87=546, + XED_IFORM_FUCOMP_ST0_X87=547, + XED_IFORM_FUCOMPP_ST0_ST1=548, + XED_IFORM_FWAIT=549, + XED_IFORM_FXAM_ST0=550, + XED_IFORM_FXCH_ST0_X87=551, + XED_IFORM_FXCH_ST0_X87_DDC1=552, + XED_IFORM_FXCH_ST0_X87_DFC1=553, + XED_IFORM_FXRSTOR_MEMmfpxenv=554, + XED_IFORM_FXRSTOR64_MEMmfpxenv=555, + XED_IFORM_FXSAVE_MEMmfpxenv=556, + XED_IFORM_FXSAVE64_MEMmfpxenv=557, + XED_IFORM_FXTRACT_ST0_ST1=558, + XED_IFORM_FYL2X_ST0_ST1=559, + XED_IFORM_FYL2XP1_ST0_ST1=560, + XED_IFORM_GETSEC=561, + XED_IFORM_HADDPD_XMMpd_MEMpd=562, + XED_IFORM_HADDPD_XMMpd_XMMpd=563, + XED_IFORM_HADDPS_XMMps_MEMps=564, + XED_IFORM_HADDPS_XMMps_XMMps=565, + XED_IFORM_HLT=566, + XED_IFORM_HSUBPD_XMMpd_MEMpd=567, + XED_IFORM_HSUBPD_XMMpd_XMMpd=568, + XED_IFORM_HSUBPS_XMMps_MEMps=569, + XED_IFORM_HSUBPS_XMMps_XMMps=570, + XED_IFORM_IDIV_GPR8=571, + XED_IFORM_IDIV_GPRv=572, + XED_IFORM_IDIV_MEMb=573, + XED_IFORM_IDIV_MEMv=574, + XED_IFORM_IMUL_GPR8=575, + XED_IFORM_IMUL_GPRv=576, + XED_IFORM_IMUL_GPRv_GPRv=577, + XED_IFORM_IMUL_GPRv_GPRv_IMMb=578, + XED_IFORM_IMUL_GPRv_GPRv_IMMz=579, + XED_IFORM_IMUL_GPRv_MEMv=580, + XED_IFORM_IMUL_GPRv_MEMv_IMMb=581, + XED_IFORM_IMUL_GPRv_MEMv_IMMz=582, + XED_IFORM_IMUL_MEMb=583, + XED_IFORM_IMUL_MEMv=584, + XED_IFORM_IN_AL_DX=585, + XED_IFORM_IN_AL_IMMb=586, + XED_IFORM_IN_OeAX_DX=587, + XED_IFORM_IN_OeAX_IMMb=588, + XED_IFORM_INC_GPR8=589, + XED_IFORM_INC_GPRv_40=590, + XED_IFORM_INC_GPRv_FFr0=591, + XED_IFORM_INC_MEMb=592, + XED_IFORM_INC_MEMv=593, + XED_IFORM_INC_LOCK_MEMb=594, + XED_IFORM_INC_LOCK_MEMv=595, + XED_IFORM_INSB=596, + XED_IFORM_INSD=597, + XED_IFORM_INSERTPS_XMMps_MEMd_IMMb=598, + XED_IFORM_INSERTPS_XMMps_XMMps_IMMb=599, + XED_IFORM_INSERTQ_XMMq_XMMdq=600, + XED_IFORM_INSERTQ_XMMq_XMMq_IMMb_IMMb=601, + XED_IFORM_INSW=602, + XED_IFORM_INT_IMMb=603, + XED_IFORM_INT1=604, + XED_IFORM_INT3=605, + XED_IFORM_INTO=606, + XED_IFORM_INVD=607, + XED_IFORM_INVEPT_GPR32_MEMdq=608, + XED_IFORM_INVEPT_GPR64_MEMdq=609, + XED_IFORM_INVLPG_MEMb=610, + XED_IFORM_INVLPGA_OrAX_ECX=611, + XED_IFORM_INVPCID_GPR32_MEMdq=612, + XED_IFORM_INVPCID_GPR64_MEMdq=613, + XED_IFORM_INVVPID_GPR32_MEMdq=614, + XED_IFORM_INVVPID_GPR64_MEMdq=615, + XED_IFORM_IRET=616, + XED_IFORM_IRETD=617, + XED_IFORM_IRETQ=618, + XED_IFORM_JB_RELBRb=619, + XED_IFORM_JB_RELBRd=620, + XED_IFORM_JB_RELBRz=621, + XED_IFORM_JBE_RELBRb=622, + XED_IFORM_JBE_RELBRd=623, + XED_IFORM_JBE_RELBRz=624, + XED_IFORM_JCXZ_RELBRb=625, + XED_IFORM_JECXZ_RELBRb=626, + XED_IFORM_JL_RELBRb=627, + XED_IFORM_JL_RELBRd=628, + XED_IFORM_JL_RELBRz=629, + XED_IFORM_JLE_RELBRb=630, + XED_IFORM_JLE_RELBRd=631, + XED_IFORM_JLE_RELBRz=632, + XED_IFORM_JMP_GPRv=633, + XED_IFORM_JMP_MEMv=634, + XED_IFORM_JMP_RELBRb=635, + XED_IFORM_JMP_RELBRd=636, + XED_IFORM_JMP_RELBRz=637, + XED_IFORM_JMP_FAR_MEMp2=638, + XED_IFORM_JMP_FAR_PTRp_IMMw=639, + XED_IFORM_JNB_RELBRb=640, + XED_IFORM_JNB_RELBRd=641, + XED_IFORM_JNB_RELBRz=642, + XED_IFORM_JNBE_RELBRb=643, + XED_IFORM_JNBE_RELBRd=644, + XED_IFORM_JNBE_RELBRz=645, + XED_IFORM_JNL_RELBRb=646, + XED_IFORM_JNL_RELBRd=647, + XED_IFORM_JNL_RELBRz=648, + XED_IFORM_JNLE_RELBRb=649, + XED_IFORM_JNLE_RELBRd=650, + XED_IFORM_JNLE_RELBRz=651, + XED_IFORM_JNO_RELBRb=652, + XED_IFORM_JNO_RELBRd=653, + XED_IFORM_JNO_RELBRz=654, + XED_IFORM_JNP_RELBRb=655, + XED_IFORM_JNP_RELBRd=656, + XED_IFORM_JNP_RELBRz=657, + XED_IFORM_JNS_RELBRb=658, + XED_IFORM_JNS_RELBRd=659, + XED_IFORM_JNS_RELBRz=660, + XED_IFORM_JNZ_RELBRb=661, + XED_IFORM_JNZ_RELBRd=662, + XED_IFORM_JNZ_RELBRz=663, + XED_IFORM_JO_RELBRb=664, + XED_IFORM_JO_RELBRd=665, + XED_IFORM_JO_RELBRz=666, + XED_IFORM_JP_RELBRb=667, + XED_IFORM_JP_RELBRd=668, + XED_IFORM_JP_RELBRz=669, + XED_IFORM_JRCXZ_RELBRb=670, + XED_IFORM_JS_RELBRb=671, + XED_IFORM_JS_RELBRd=672, + XED_IFORM_JS_RELBRz=673, + XED_IFORM_JZ_RELBRb=674, + XED_IFORM_JZ_RELBRd=675, + XED_IFORM_JZ_RELBRz=676, + XED_IFORM_KADDB_MASKmskw_MASKmskw_MASKmskw_AVX512=677, + XED_IFORM_KADDD_MASKmskw_MASKmskw_MASKmskw_AVX512=678, + XED_IFORM_KADDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=679, + XED_IFORM_KADDW_MASKmskw_MASKmskw_MASKmskw_AVX512=680, + XED_IFORM_KANDB_MASKmskw_MASKmskw_MASKmskw_AVX512=681, + XED_IFORM_KANDD_MASKmskw_MASKmskw_MASKmskw_AVX512=682, + XED_IFORM_KANDNB_MASKmskw_MASKmskw_MASKmskw_AVX512=683, + XED_IFORM_KANDND_MASKmskw_MASKmskw_MASKmskw_AVX512=684, + XED_IFORM_KANDNQ_MASKmskw_MASKmskw_MASKmskw_AVX512=685, + XED_IFORM_KANDNW_MASKmskw_MASKmskw_MASKmskw_AVX512=686, + XED_IFORM_KANDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=687, + XED_IFORM_KANDW_MASKmskw_MASKmskw_MASKmskw_AVX512=688, + XED_IFORM_KMOVB_GPR32u32_MASKmskw_AVX512=689, + XED_IFORM_KMOVB_MASKmskw_GPR32u32_AVX512=690, + XED_IFORM_KMOVB_MASKmskw_MASKu8_AVX512=691, + XED_IFORM_KMOVB_MASKmskw_MEMu8_AVX512=692, + XED_IFORM_KMOVB_MEMu8_MASKmskw_AVX512=693, + XED_IFORM_KMOVD_GPR32u32_MASKmskw_AVX512=694, + XED_IFORM_KMOVD_MASKmskw_GPR32u32_AVX512=695, + XED_IFORM_KMOVD_MASKmskw_MASKu32_AVX512=696, + XED_IFORM_KMOVD_MASKmskw_MEMu32_AVX512=697, + XED_IFORM_KMOVD_MEMu32_MASKmskw_AVX512=698, + XED_IFORM_KMOVQ_GPR64u64_MASKmskw_AVX512=699, + XED_IFORM_KMOVQ_MASKmskw_GPR64u64_AVX512=700, + XED_IFORM_KMOVQ_MASKmskw_MASKu64_AVX512=701, + XED_IFORM_KMOVQ_MASKmskw_MEMu64_AVX512=702, + XED_IFORM_KMOVQ_MEMu64_MASKmskw_AVX512=703, + XED_IFORM_KMOVW_GPR32u32_MASKmskw_AVX512=704, + XED_IFORM_KMOVW_MASKmskw_GPR32u32_AVX512=705, + XED_IFORM_KMOVW_MASKmskw_MASKu16_AVX512=706, + XED_IFORM_KMOVW_MASKmskw_MEMu16_AVX512=707, + XED_IFORM_KMOVW_MEMu16_MASKmskw_AVX512=708, + XED_IFORM_KNOTB_MASKmskw_MASKmskw_AVX512=709, + XED_IFORM_KNOTD_MASKmskw_MASKmskw_AVX512=710, + XED_IFORM_KNOTQ_MASKmskw_MASKmskw_AVX512=711, + XED_IFORM_KNOTW_MASKmskw_MASKmskw_AVX512=712, + XED_IFORM_KORB_MASKmskw_MASKmskw_MASKmskw_AVX512=713, + XED_IFORM_KORD_MASKmskw_MASKmskw_MASKmskw_AVX512=714, + XED_IFORM_KORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=715, + XED_IFORM_KORTESTB_MASKmskw_MASKmskw_AVX512=716, + XED_IFORM_KORTESTD_MASKmskw_MASKmskw_AVX512=717, + XED_IFORM_KORTESTQ_MASKmskw_MASKmskw_AVX512=718, + XED_IFORM_KORTESTW_MASKmskw_MASKmskw_AVX512=719, + XED_IFORM_KORW_MASKmskw_MASKmskw_MASKmskw_AVX512=720, + XED_IFORM_KSHIFTLB_MASKmskw_MASKmskw_IMM8_AVX512=721, + XED_IFORM_KSHIFTLD_MASKmskw_MASKmskw_IMM8_AVX512=722, + XED_IFORM_KSHIFTLQ_MASKmskw_MASKmskw_IMM8_AVX512=723, + XED_IFORM_KSHIFTLW_MASKmskw_MASKmskw_IMM8_AVX512=724, + XED_IFORM_KSHIFTRB_MASKmskw_MASKmskw_IMM8_AVX512=725, + XED_IFORM_KSHIFTRD_MASKmskw_MASKmskw_IMM8_AVX512=726, + XED_IFORM_KSHIFTRQ_MASKmskw_MASKmskw_IMM8_AVX512=727, + XED_IFORM_KSHIFTRW_MASKmskw_MASKmskw_IMM8_AVX512=728, + XED_IFORM_KTESTB_MASKmskw_MASKmskw_AVX512=729, + XED_IFORM_KTESTD_MASKmskw_MASKmskw_AVX512=730, + XED_IFORM_KTESTQ_MASKmskw_MASKmskw_AVX512=731, + XED_IFORM_KTESTW_MASKmskw_MASKmskw_AVX512=732, + XED_IFORM_KUNPCKBW_MASKmskw_MASKmskw_MASKmskw_AVX512=733, + XED_IFORM_KUNPCKDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=734, + XED_IFORM_KUNPCKWD_MASKmskw_MASKmskw_MASKmskw_AVX512=735, + XED_IFORM_KXNORB_MASKmskw_MASKmskw_MASKmskw_AVX512=736, + XED_IFORM_KXNORD_MASKmskw_MASKmskw_MASKmskw_AVX512=737, + XED_IFORM_KXNORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=738, + XED_IFORM_KXNORW_MASKmskw_MASKmskw_MASKmskw_AVX512=739, + XED_IFORM_KXORB_MASKmskw_MASKmskw_MASKmskw_AVX512=740, + XED_IFORM_KXORD_MASKmskw_MASKmskw_MASKmskw_AVX512=741, + XED_IFORM_KXORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=742, + XED_IFORM_KXORW_MASKmskw_MASKmskw_MASKmskw_AVX512=743, + XED_IFORM_LAHF=744, + XED_IFORM_LAR_GPRv_GPRv=745, + XED_IFORM_LAR_GPRv_MEMw=746, + XED_IFORM_LDDQU_XMMpd_MEMdq=747, + XED_IFORM_LDMXCSR_MEMd=748, + XED_IFORM_LDS_GPRz_MEMp=749, + XED_IFORM_LEA_GPRv_AGEN=750, + XED_IFORM_LEAVE=751, + XED_IFORM_LES_GPRz_MEMp=752, + XED_IFORM_LFENCE=753, + XED_IFORM_LFS_GPRv_MEMp2=754, + XED_IFORM_LGDT_MEMs=755, + XED_IFORM_LGDT_MEMs64=756, + XED_IFORM_LGS_GPRv_MEMp2=757, + XED_IFORM_LIDT_MEMs=758, + XED_IFORM_LIDT_MEMs64=759, + XED_IFORM_LLDT_GPR16=760, + XED_IFORM_LLDT_MEMw=761, + XED_IFORM_LLWPCB_GPRyy=762, + XED_IFORM_LMSW_GPR16=763, + XED_IFORM_LMSW_MEMw=764, + XED_IFORM_LODSB=765, + XED_IFORM_LODSD=766, + XED_IFORM_LODSQ=767, + XED_IFORM_LODSW=768, + XED_IFORM_LOOP_RELBRb=769, + XED_IFORM_LOOPE_RELBRb=770, + XED_IFORM_LOOPNE_RELBRb=771, + XED_IFORM_LSL_GPRv_GPRz=772, + XED_IFORM_LSL_GPRv_MEMw=773, + XED_IFORM_LSS_GPRv_MEMp2=774, + XED_IFORM_LTR_GPR16=775, + XED_IFORM_LTR_MEMw=776, + XED_IFORM_LWPINS_GPRyy_GPRvd_IMMd=777, + XED_IFORM_LWPINS_GPRyy_MEMd_IMMd=778, + XED_IFORM_LWPVAL_GPRyy_GPRvd_IMMd=779, + XED_IFORM_LWPVAL_GPRyy_MEMd_IMMd=780, + XED_IFORM_LZCNT_GPRv_GPRv=781, + XED_IFORM_LZCNT_GPRv_MEMv=782, + XED_IFORM_MASKMOVDQU_XMMdq_XMMdq=783, + XED_IFORM_MASKMOVQ_MMXq_MMXq=784, + XED_IFORM_MAXPD_XMMpd_MEMpd=785, + XED_IFORM_MAXPD_XMMpd_XMMpd=786, + XED_IFORM_MAXPS_XMMps_MEMps=787, + XED_IFORM_MAXPS_XMMps_XMMps=788, + XED_IFORM_MAXSD_XMMsd_MEMsd=789, + XED_IFORM_MAXSD_XMMsd_XMMsd=790, + XED_IFORM_MAXSS_XMMss_MEMss=791, + XED_IFORM_MAXSS_XMMss_XMMss=792, + XED_IFORM_MFENCE=793, + XED_IFORM_MINPD_XMMpd_MEMpd=794, + XED_IFORM_MINPD_XMMpd_XMMpd=795, + XED_IFORM_MINPS_XMMps_MEMps=796, + XED_IFORM_MINPS_XMMps_XMMps=797, + XED_IFORM_MINSD_XMMsd_MEMsd=798, + XED_IFORM_MINSD_XMMsd_XMMsd=799, + XED_IFORM_MINSS_XMMss_MEMss=800, + XED_IFORM_MINSS_XMMss_XMMss=801, + XED_IFORM_MONITOR=802, + XED_IFORM_MOV_AL_MEMb=803, + XED_IFORM_MOV_GPR8_GPR8_88=804, + XED_IFORM_MOV_GPR8_GPR8_8A=805, + XED_IFORM_MOV_GPR8_IMMb_C6r0=806, + XED_IFORM_MOV_GPR8_IMMb_D0=807, + XED_IFORM_MOV_GPR8_MEMb=808, + XED_IFORM_MOV_GPRv_GPRv_89=809, + XED_IFORM_MOV_GPRv_GPRv_8B=810, + XED_IFORM_MOV_GPRv_IMMv=811, + XED_IFORM_MOV_GPRv_IMMz=812, + XED_IFORM_MOV_GPRv_MEMv=813, + XED_IFORM_MOV_GPRv_SEG=814, + XED_IFORM_MOV_MEMb_AL=815, + XED_IFORM_MOV_MEMb_GPR8=816, + XED_IFORM_MOV_MEMb_IMMb=817, + XED_IFORM_MOV_MEMv_GPRv=818, + XED_IFORM_MOV_MEMv_IMMz=819, + XED_IFORM_MOV_MEMv_OrAX=820, + XED_IFORM_MOV_MEMw_SEG=821, + XED_IFORM_MOV_OrAX_MEMv=822, + XED_IFORM_MOV_SEG_GPR16=823, + XED_IFORM_MOV_SEG_MEMw=824, + XED_IFORM_MOVAPD_MEMpd_XMMpd=825, + XED_IFORM_MOVAPD_XMMpd_MEMpd=826, + XED_IFORM_MOVAPD_XMMpd_XMMpd_0F28=827, + XED_IFORM_MOVAPD_XMMpd_XMMpd_0F29=828, + XED_IFORM_MOVAPS_MEMps_XMMps=829, + XED_IFORM_MOVAPS_XMMps_MEMps=830, + XED_IFORM_MOVAPS_XMMps_XMMps_0F28=831, + XED_IFORM_MOVAPS_XMMps_XMMps_0F29=832, + XED_IFORM_MOVBE_GPRv_MEMv=833, + XED_IFORM_MOVBE_MEMv_GPRv=834, + XED_IFORM_MOVD_GPR32_MMXd=835, + XED_IFORM_MOVD_GPR32_XMMd=836, + XED_IFORM_MOVD_MEMd_MMXd=837, + XED_IFORM_MOVD_MEMd_XMMd=838, + XED_IFORM_MOVD_MMXq_GPR32=839, + XED_IFORM_MOVD_MMXq_MEMd=840, + XED_IFORM_MOVD_XMMdq_GPR32=841, + XED_IFORM_MOVD_XMMdq_MEMd=842, + XED_IFORM_MOVDDUP_XMMdq_MEMq=843, + XED_IFORM_MOVDDUP_XMMdq_XMMq=844, + XED_IFORM_MOVDQ2Q_MMXq_XMMq=845, + XED_IFORM_MOVDQA_MEMdq_XMMdq=846, + XED_IFORM_MOVDQA_XMMdq_MEMdq=847, + XED_IFORM_MOVDQA_XMMdq_XMMdq_0F6F=848, + XED_IFORM_MOVDQA_XMMdq_XMMdq_0F7F=849, + XED_IFORM_MOVDQU_MEMdq_XMMdq=850, + XED_IFORM_MOVDQU_XMMdq_MEMdq=851, + XED_IFORM_MOVDQU_XMMdq_XMMdq_0F6F=852, + XED_IFORM_MOVDQU_XMMdq_XMMdq_0F7F=853, + XED_IFORM_MOVHLPS_XMMq_XMMq=854, + XED_IFORM_MOVHPD_MEMq_XMMsd=855, + XED_IFORM_MOVHPD_XMMsd_MEMq=856, + XED_IFORM_MOVHPS_MEMq_XMMps=857, + XED_IFORM_MOVHPS_XMMq_MEMq=858, + XED_IFORM_MOVLHPS_XMMq_XMMq=859, + XED_IFORM_MOVLPD_MEMq_XMMsd=860, + XED_IFORM_MOVLPD_XMMsd_MEMq=861, + XED_IFORM_MOVLPS_MEMq_XMMps=862, + XED_IFORM_MOVLPS_XMMq_MEMq=863, + XED_IFORM_MOVMSKPD_GPR32_XMMpd=864, + XED_IFORM_MOVMSKPS_GPR32_XMMps=865, + XED_IFORM_MOVNTDQ_MEMdq_XMMdq=866, + XED_IFORM_MOVNTDQA_XMMdq_MEMdq=867, + XED_IFORM_MOVNTI_MEMd_GPR32=868, + XED_IFORM_MOVNTI_MEMq_GPR64=869, + XED_IFORM_MOVNTPD_MEMdq_XMMpd=870, + XED_IFORM_MOVNTPS_MEMdq_XMMps=871, + XED_IFORM_MOVNTQ_MEMq_MMXq=872, + XED_IFORM_MOVNTSD_MEMq_XMMq=873, + XED_IFORM_MOVNTSS_MEMd_XMMd=874, + XED_IFORM_MOVQ_GPR64_MMXq=875, + XED_IFORM_MOVQ_GPR64_XMMq=876, + XED_IFORM_MOVQ_MEMq_MMXq_0F7E=877, + XED_IFORM_MOVQ_MEMq_MMXq_0F7F=878, + XED_IFORM_MOVQ_MEMq_XMMq_0F7E=879, + XED_IFORM_MOVQ_MEMq_XMMq_0FD6=880, + XED_IFORM_MOVQ_MMXq_GPR64=881, + XED_IFORM_MOVQ_MMXq_MEMq_0F6E=882, + XED_IFORM_MOVQ_MMXq_MEMq_0F6F=883, + XED_IFORM_MOVQ_MMXq_MMXq_0F6F=884, + XED_IFORM_MOVQ_MMXq_MMXq_0F7F=885, + XED_IFORM_MOVQ_XMMdq_GPR64=886, + XED_IFORM_MOVQ_XMMdq_MEMq_0F6E=887, + XED_IFORM_MOVQ_XMMdq_MEMq_0F7E=888, + XED_IFORM_MOVQ_XMMdq_XMMq_0F7E=889, + XED_IFORM_MOVQ_XMMdq_XMMq_0FD6=890, + XED_IFORM_MOVQ2DQ_XMMdq_MMXq=891, + XED_IFORM_MOVSB=892, + XED_IFORM_MOVSD=893, + XED_IFORM_MOVSD_XMM_MEMsd_XMMsd=894, + XED_IFORM_MOVSD_XMM_XMMdq_MEMsd=895, + XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F10=896, + XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F11=897, + XED_IFORM_MOVSHDUP_XMMps_MEMps=898, + XED_IFORM_MOVSHDUP_XMMps_XMMps=899, + XED_IFORM_MOVSLDUP_XMMps_MEMps=900, + XED_IFORM_MOVSLDUP_XMMps_XMMps=901, + XED_IFORM_MOVSQ=902, + XED_IFORM_MOVSS_MEMss_XMMss=903, + XED_IFORM_MOVSS_XMMdq_MEMss=904, + XED_IFORM_MOVSS_XMMss_XMMss_0F10=905, + XED_IFORM_MOVSS_XMMss_XMMss_0F11=906, + XED_IFORM_MOVSW=907, + XED_IFORM_MOVSX_GPRv_GPR16=908, + XED_IFORM_MOVSX_GPRv_GPR8=909, + XED_IFORM_MOVSX_GPRv_MEMb=910, + XED_IFORM_MOVSX_GPRv_MEMw=911, + XED_IFORM_MOVSXD_GPRv_GPR32=912, + XED_IFORM_MOVSXD_GPRv_MEMd=913, + XED_IFORM_MOVUPD_MEMpd_XMMpd=914, + XED_IFORM_MOVUPD_XMMpd_MEMpd=915, + XED_IFORM_MOVUPD_XMMpd_XMMpd_0F10=916, + XED_IFORM_MOVUPD_XMMpd_XMMpd_0F11=917, + XED_IFORM_MOVUPS_MEMps_XMMps=918, + XED_IFORM_MOVUPS_XMMps_MEMps=919, + XED_IFORM_MOVUPS_XMMps_XMMps_0F10=920, + XED_IFORM_MOVUPS_XMMps_XMMps_0F11=921, + XED_IFORM_MOVZX_GPRv_GPR16=922, + XED_IFORM_MOVZX_GPRv_GPR8=923, + XED_IFORM_MOVZX_GPRv_MEMb=924, + XED_IFORM_MOVZX_GPRv_MEMw=925, + XED_IFORM_MOV_CR_CR_GPR32=926, + XED_IFORM_MOV_CR_CR_GPR64=927, + XED_IFORM_MOV_CR_GPR32_CR=928, + XED_IFORM_MOV_CR_GPR64_CR=929, + XED_IFORM_MOV_DR_DR_GPR32=930, + XED_IFORM_MOV_DR_DR_GPR64=931, + XED_IFORM_MOV_DR_GPR32_DR=932, + XED_IFORM_MOV_DR_GPR64_DR=933, + XED_IFORM_MPSADBW_XMMdq_MEMdq_IMMb=934, + XED_IFORM_MPSADBW_XMMdq_XMMdq_IMMb=935, + XED_IFORM_MUL_GPR8=936, + XED_IFORM_MUL_GPRv=937, + XED_IFORM_MUL_MEMb=938, + XED_IFORM_MUL_MEMv=939, + XED_IFORM_MULPD_XMMpd_MEMpd=940, + XED_IFORM_MULPD_XMMpd_XMMpd=941, + XED_IFORM_MULPS_XMMps_MEMps=942, + XED_IFORM_MULPS_XMMps_XMMps=943, + XED_IFORM_MULSD_XMMsd_MEMsd=944, + XED_IFORM_MULSD_XMMsd_XMMsd=945, + XED_IFORM_MULSS_XMMss_MEMss=946, + XED_IFORM_MULSS_XMMss_XMMss=947, + XED_IFORM_MULX_VGPR32d_VGPR32d_MEMd=948, + XED_IFORM_MULX_VGPR32d_VGPR32d_VGPR32d=949, + XED_IFORM_MULX_VGPR64q_VGPR64q_MEMq=950, + XED_IFORM_MULX_VGPR64q_VGPR64q_VGPR64q=951, + XED_IFORM_MWAIT=952, + XED_IFORM_NEG_GPR8=953, + XED_IFORM_NEG_GPRv=954, + XED_IFORM_NEG_MEMb=955, + XED_IFORM_NEG_MEMv=956, + XED_IFORM_NEG_LOCK_MEMb=957, + XED_IFORM_NEG_LOCK_MEMv=958, + XED_IFORM_NOP_90=959, + XED_IFORM_NOP_GPRv_0F18r0=960, + XED_IFORM_NOP_GPRv_0F18r1=961, + XED_IFORM_NOP_GPRv_0F18r2=962, + XED_IFORM_NOP_GPRv_0F18r3=963, + XED_IFORM_NOP_GPRv_0F18r4=964, + XED_IFORM_NOP_GPRv_0F18r5=965, + XED_IFORM_NOP_GPRv_0F18r6=966, + XED_IFORM_NOP_GPRv_0F18r7=967, + XED_IFORM_NOP_GPRv_GPRv_0F0D=968, + XED_IFORM_NOP_GPRv_GPRv_0F19=969, + XED_IFORM_NOP_GPRv_GPRv_0F1A=970, + XED_IFORM_NOP_GPRv_GPRv_0F1B=971, + XED_IFORM_NOP_GPRv_GPRv_0F1C=972, + XED_IFORM_NOP_GPRv_GPRv_0F1D=973, + XED_IFORM_NOP_GPRv_GPRv_0F1E=974, + XED_IFORM_NOP_GPRv_GPRv_0F1F=975, + XED_IFORM_NOP_GPRv_MEM_0F1B=976, + XED_IFORM_NOP_GPRv_MEMv_0F1A=977, + XED_IFORM_NOP_MEMv_0F18r4=978, + XED_IFORM_NOP_MEMv_0F18r5=979, + XED_IFORM_NOP_MEMv_0F18r6=980, + XED_IFORM_NOP_MEMv_0F18r7=981, + XED_IFORM_NOP_MEMv_GPRv_0F19=982, + XED_IFORM_NOP_MEMv_GPRv_0F1C=983, + XED_IFORM_NOP_MEMv_GPRv_0F1D=984, + XED_IFORM_NOP_MEMv_GPRv_0F1E=985, + XED_IFORM_NOP_MEMv_GPRv_0F1F=986, + XED_IFORM_NOT_GPR8=987, + XED_IFORM_NOT_GPRv=988, + XED_IFORM_NOT_MEMb=989, + XED_IFORM_NOT_MEMv=990, + XED_IFORM_NOT_LOCK_MEMb=991, + XED_IFORM_NOT_LOCK_MEMv=992, + XED_IFORM_OR_AL_IMMb=993, + XED_IFORM_OR_GPR8_GPR8_08=994, + XED_IFORM_OR_GPR8_GPR8_0A=995, + XED_IFORM_OR_GPR8_IMMb_80r1=996, + XED_IFORM_OR_GPR8_IMMb_82r1=997, + XED_IFORM_OR_GPR8_MEMb=998, + XED_IFORM_OR_GPRv_GPRv_09=999, + XED_IFORM_OR_GPRv_GPRv_0B=1000, + XED_IFORM_OR_GPRv_IMMb=1001, + XED_IFORM_OR_GPRv_IMMz=1002, + XED_IFORM_OR_GPRv_MEMv=1003, + XED_IFORM_OR_MEMb_GPR8=1004, + XED_IFORM_OR_MEMb_IMMb_80r1=1005, + XED_IFORM_OR_MEMb_IMMb_82r1=1006, + XED_IFORM_OR_MEMv_GPRv=1007, + XED_IFORM_OR_MEMv_IMMb=1008, + XED_IFORM_OR_MEMv_IMMz=1009, + XED_IFORM_OR_OrAX_IMMz=1010, + XED_IFORM_ORPD_XMMpd_MEMpd=1011, + XED_IFORM_ORPD_XMMpd_XMMpd=1012, + XED_IFORM_ORPS_XMMps_MEMps=1013, + XED_IFORM_ORPS_XMMps_XMMps=1014, + XED_IFORM_OR_LOCK_MEMb_GPR8=1015, + XED_IFORM_OR_LOCK_MEMb_IMMb_80r1=1016, + XED_IFORM_OR_LOCK_MEMb_IMMb_82r1=1017, + XED_IFORM_OR_LOCK_MEMv_GPRv=1018, + XED_IFORM_OR_LOCK_MEMv_IMMb=1019, + XED_IFORM_OR_LOCK_MEMv_IMMz=1020, + XED_IFORM_OUT_DX_AL=1021, + XED_IFORM_OUT_DX_OeAX=1022, + XED_IFORM_OUT_IMMb_AL=1023, + XED_IFORM_OUT_IMMb_OeAX=1024, + XED_IFORM_OUTSB=1025, + XED_IFORM_OUTSD=1026, + XED_IFORM_OUTSW=1027, + XED_IFORM_PABSB_MMXq_MEMq=1028, + XED_IFORM_PABSB_MMXq_MMXq=1029, + XED_IFORM_PABSB_XMMdq_MEMdq=1030, + XED_IFORM_PABSB_XMMdq_XMMdq=1031, + XED_IFORM_PABSD_MMXq_MEMq=1032, + XED_IFORM_PABSD_MMXq_MMXq=1033, + XED_IFORM_PABSD_XMMdq_MEMdq=1034, + XED_IFORM_PABSD_XMMdq_XMMdq=1035, + XED_IFORM_PABSW_MMXq_MEMq=1036, + XED_IFORM_PABSW_MMXq_MMXq=1037, + XED_IFORM_PABSW_XMMdq_MEMdq=1038, + XED_IFORM_PABSW_XMMdq_XMMdq=1039, + XED_IFORM_PACKSSDW_MMXq_MEMq=1040, + XED_IFORM_PACKSSDW_MMXq_MMXq=1041, + XED_IFORM_PACKSSDW_XMMdq_MEMdq=1042, + XED_IFORM_PACKSSDW_XMMdq_XMMdq=1043, + XED_IFORM_PACKSSWB_MMXq_MEMq=1044, + XED_IFORM_PACKSSWB_MMXq_MMXq=1045, + XED_IFORM_PACKSSWB_XMMdq_MEMdq=1046, + XED_IFORM_PACKSSWB_XMMdq_XMMdq=1047, + XED_IFORM_PACKUSDW_XMMdq_MEMdq=1048, + XED_IFORM_PACKUSDW_XMMdq_XMMdq=1049, + XED_IFORM_PACKUSWB_MMXq_MEMq=1050, + XED_IFORM_PACKUSWB_MMXq_MMXq=1051, + XED_IFORM_PACKUSWB_XMMdq_MEMdq=1052, + XED_IFORM_PACKUSWB_XMMdq_XMMdq=1053, + XED_IFORM_PADDB_MMXq_MEMq=1054, + XED_IFORM_PADDB_MMXq_MMXq=1055, + XED_IFORM_PADDB_XMMdq_MEMdq=1056, + XED_IFORM_PADDB_XMMdq_XMMdq=1057, + XED_IFORM_PADDD_MMXq_MEMq=1058, + XED_IFORM_PADDD_MMXq_MMXq=1059, + XED_IFORM_PADDD_XMMdq_MEMdq=1060, + XED_IFORM_PADDD_XMMdq_XMMdq=1061, + XED_IFORM_PADDQ_MMXq_MEMq=1062, + XED_IFORM_PADDQ_MMXq_MMXq=1063, + XED_IFORM_PADDQ_XMMdq_MEMdq=1064, + XED_IFORM_PADDQ_XMMdq_XMMdq=1065, + XED_IFORM_PADDSB_MMXq_MEMq=1066, + XED_IFORM_PADDSB_MMXq_MMXq=1067, + XED_IFORM_PADDSB_XMMdq_MEMdq=1068, + XED_IFORM_PADDSB_XMMdq_XMMdq=1069, + XED_IFORM_PADDSW_MMXq_MEMq=1070, + XED_IFORM_PADDSW_MMXq_MMXq=1071, + XED_IFORM_PADDSW_XMMdq_MEMdq=1072, + XED_IFORM_PADDSW_XMMdq_XMMdq=1073, + XED_IFORM_PADDUSB_MMXq_MEMq=1074, + XED_IFORM_PADDUSB_MMXq_MMXq=1075, + XED_IFORM_PADDUSB_XMMdq_MEMdq=1076, + XED_IFORM_PADDUSB_XMMdq_XMMdq=1077, + XED_IFORM_PADDUSW_MMXq_MEMq=1078, + XED_IFORM_PADDUSW_MMXq_MMXq=1079, + XED_IFORM_PADDUSW_XMMdq_MEMdq=1080, + XED_IFORM_PADDUSW_XMMdq_XMMdq=1081, + XED_IFORM_PADDW_MMXq_MEMq=1082, + XED_IFORM_PADDW_MMXq_MMXq=1083, + XED_IFORM_PADDW_XMMdq_MEMdq=1084, + XED_IFORM_PADDW_XMMdq_XMMdq=1085, + XED_IFORM_PALIGNR_MMXq_MEMq_IMMb=1086, + XED_IFORM_PALIGNR_MMXq_MMXq_IMMb=1087, + XED_IFORM_PALIGNR_XMMdq_MEMdq_IMMb=1088, + XED_IFORM_PALIGNR_XMMdq_XMMdq_IMMb=1089, + XED_IFORM_PAND_MMXq_MEMq=1090, + XED_IFORM_PAND_MMXq_MMXq=1091, + XED_IFORM_PAND_XMMdq_MEMdq=1092, + XED_IFORM_PAND_XMMdq_XMMdq=1093, + XED_IFORM_PANDN_MMXq_MEMq=1094, + XED_IFORM_PANDN_MMXq_MMXq=1095, + XED_IFORM_PANDN_XMMdq_MEMdq=1096, + XED_IFORM_PANDN_XMMdq_XMMdq=1097, + XED_IFORM_PAUSE=1098, + XED_IFORM_PAVGB_MMXq_MEMq=1099, + XED_IFORM_PAVGB_MMXq_MMXq=1100, + XED_IFORM_PAVGB_XMMdq_MEMdq=1101, + XED_IFORM_PAVGB_XMMdq_XMMdq=1102, + XED_IFORM_PAVGUSB_MMXq_MEMq=1103, + XED_IFORM_PAVGUSB_MMXq_MMXq=1104, + XED_IFORM_PAVGW_MMXq_MEMq=1105, + XED_IFORM_PAVGW_MMXq_MMXq=1106, + XED_IFORM_PAVGW_XMMdq_MEMdq=1107, + XED_IFORM_PAVGW_XMMdq_XMMdq=1108, + XED_IFORM_PBLENDVB_XMMdq_MEMdq=1109, + XED_IFORM_PBLENDVB_XMMdq_XMMdq=1110, + XED_IFORM_PBLENDW_XMMdq_MEMdq_IMMb=1111, + XED_IFORM_PBLENDW_XMMdq_XMMdq_IMMb=1112, + XED_IFORM_PCLMULQDQ_XMMdq_MEMdq_IMMb=1113, + XED_IFORM_PCLMULQDQ_XMMdq_XMMdq_IMMb=1114, + XED_IFORM_PCMPEQB_MMXq_MEMq=1115, + XED_IFORM_PCMPEQB_MMXq_MMXq=1116, + XED_IFORM_PCMPEQB_XMMdq_MEMdq=1117, + XED_IFORM_PCMPEQB_XMMdq_XMMdq=1118, + XED_IFORM_PCMPEQD_MMXq_MEMq=1119, + XED_IFORM_PCMPEQD_MMXq_MMXq=1120, + XED_IFORM_PCMPEQD_XMMdq_MEMdq=1121, + XED_IFORM_PCMPEQD_XMMdq_XMMdq=1122, + XED_IFORM_PCMPEQQ_XMMdq_MEMdq=1123, + XED_IFORM_PCMPEQQ_XMMdq_XMMdq=1124, + XED_IFORM_PCMPEQW_MMXq_MEMq=1125, + XED_IFORM_PCMPEQW_MMXq_MMXq=1126, + XED_IFORM_PCMPEQW_XMMdq_MEMdq=1127, + XED_IFORM_PCMPEQW_XMMdq_XMMdq=1128, + XED_IFORM_PCMPESTRI_XMMdq_MEMdq_IMMb=1129, + XED_IFORM_PCMPESTRI_XMMdq_XMMdq_IMMb=1130, + XED_IFORM_PCMPESTRM_XMMdq_MEMdq_IMMb=1131, + XED_IFORM_PCMPESTRM_XMMdq_XMMdq_IMMb=1132, + XED_IFORM_PCMPGTB_MMXq_MEMq=1133, + XED_IFORM_PCMPGTB_MMXq_MMXq=1134, + XED_IFORM_PCMPGTB_XMMdq_MEMdq=1135, + XED_IFORM_PCMPGTB_XMMdq_XMMdq=1136, + XED_IFORM_PCMPGTD_MMXq_MEMq=1137, + XED_IFORM_PCMPGTD_MMXq_MMXq=1138, + XED_IFORM_PCMPGTD_XMMdq_MEMdq=1139, + XED_IFORM_PCMPGTD_XMMdq_XMMdq=1140, + XED_IFORM_PCMPGTQ_XMMdq_MEMdq=1141, + XED_IFORM_PCMPGTQ_XMMdq_XMMdq=1142, + XED_IFORM_PCMPGTW_MMXq_MEMq=1143, + XED_IFORM_PCMPGTW_MMXq_MMXq=1144, + XED_IFORM_PCMPGTW_XMMdq_MEMdq=1145, + XED_IFORM_PCMPGTW_XMMdq_XMMdq=1146, + XED_IFORM_PCMPISTRI_XMMdq_MEMdq_IMMb=1147, + XED_IFORM_PCMPISTRI_XMMdq_XMMdq_IMMb=1148, + XED_IFORM_PCMPISTRM_XMMdq_MEMdq_IMMb=1149, + XED_IFORM_PCMPISTRM_XMMdq_XMMdq_IMMb=1150, + XED_IFORM_PCOMMIT=1151, + XED_IFORM_PDEP_VGPR32d_VGPR32d_MEMd=1152, + XED_IFORM_PDEP_VGPR32d_VGPR32d_VGPR32d=1153, + XED_IFORM_PDEP_VGPR64q_VGPR64q_MEMq=1154, + XED_IFORM_PDEP_VGPR64q_VGPR64q_VGPR64q=1155, + XED_IFORM_PEXT_VGPR32d_VGPR32d_MEMd=1156, + XED_IFORM_PEXT_VGPR32d_VGPR32d_VGPR32d=1157, + XED_IFORM_PEXT_VGPR64q_VGPR64q_MEMq=1158, + XED_IFORM_PEXT_VGPR64q_VGPR64q_VGPR64q=1159, + XED_IFORM_PEXTRB_GPR32d_XMMdq_IMMb=1160, + XED_IFORM_PEXTRB_MEMb_XMMdq_IMMb=1161, + XED_IFORM_PEXTRD_GPR32d_XMMdq_IMMb=1162, + XED_IFORM_PEXTRD_MEMd_XMMdq_IMMb=1163, + XED_IFORM_PEXTRQ_GPR64q_XMMdq_IMMb=1164, + XED_IFORM_PEXTRQ_MEMq_XMMdq_IMMb=1165, + XED_IFORM_PEXTRW_GPR32_MMXq_IMMb=1166, + XED_IFORM_PEXTRW_GPR32_XMMdq_IMMb=1167, + XED_IFORM_PEXTRW_SSE4_GPR32_XMMdq_IMMb=1168, + XED_IFORM_PEXTRW_SSE4_MEMw_XMMdq_IMMb=1169, + XED_IFORM_PF2ID_MMXq_MEMq=1170, + XED_IFORM_PF2ID_MMXq_MMXq=1171, + XED_IFORM_PF2IW_MMXq_MEMq=1172, + XED_IFORM_PF2IW_MMXq_MMXq=1173, + XED_IFORM_PFACC_MMXq_MEMq=1174, + XED_IFORM_PFACC_MMXq_MMXq=1175, + XED_IFORM_PFADD_MMXq_MEMq=1176, + XED_IFORM_PFADD_MMXq_MMXq=1177, + XED_IFORM_PFCMPEQ_MMXq_MEMq=1178, + XED_IFORM_PFCMPEQ_MMXq_MMXq=1179, + XED_IFORM_PFCMPGE_MMXq_MEMq=1180, + XED_IFORM_PFCMPGE_MMXq_MMXq=1181, + XED_IFORM_PFCMPGT_MMXq_MEMq=1182, + XED_IFORM_PFCMPGT_MMXq_MMXq=1183, + XED_IFORM_PFCPIT1_MMXq_MEMq=1184, + XED_IFORM_PFCPIT1_MMXq_MMXq=1185, + XED_IFORM_PFMAX_MMXq_MEMq=1186, + XED_IFORM_PFMAX_MMXq_MMXq=1187, + XED_IFORM_PFMIN_MMXq_MEMq=1188, + XED_IFORM_PFMIN_MMXq_MMXq=1189, + XED_IFORM_PFMUL_MMXq_MEMq=1190, + XED_IFORM_PFMUL_MMXq_MMXq=1191, + XED_IFORM_PFNACC_MMXq_MEMq=1192, + XED_IFORM_PFNACC_MMXq_MMXq=1193, + XED_IFORM_PFPNACC_MMXq_MEMq=1194, + XED_IFORM_PFPNACC_MMXq_MMXq=1195, + XED_IFORM_PFRCP_MMXq_MEMq=1196, + XED_IFORM_PFRCP_MMXq_MMXq=1197, + XED_IFORM_PFRCPIT2_MMXq_MEMq=1198, + XED_IFORM_PFRCPIT2_MMXq_MMXq=1199, + XED_IFORM_PFRSQIT1_MMXq_MEMq=1200, + XED_IFORM_PFRSQIT1_MMXq_MMXq=1201, + XED_IFORM_PFSQRT_MMXq_MEMq=1202, + XED_IFORM_PFSQRT_MMXq_MMXq=1203, + XED_IFORM_PFSUB_MMXq_MEMq=1204, + XED_IFORM_PFSUB_MMXq_MMXq=1205, + XED_IFORM_PFSUBR_MMXq_MEMq=1206, + XED_IFORM_PFSUBR_MMXq_MMXq=1207, + XED_IFORM_PHADDD_MMXq_MEMq=1208, + XED_IFORM_PHADDD_MMXq_MMXq=1209, + XED_IFORM_PHADDD_XMMdq_MEMdq=1210, + XED_IFORM_PHADDD_XMMdq_XMMdq=1211, + XED_IFORM_PHADDSW_MMXq_MEMq=1212, + XED_IFORM_PHADDSW_MMXq_MMXq=1213, + XED_IFORM_PHADDSW_XMMdq_MEMdq=1214, + XED_IFORM_PHADDSW_XMMdq_XMMdq=1215, + XED_IFORM_PHADDW_MMXq_MEMq=1216, + XED_IFORM_PHADDW_MMXq_MMXq=1217, + XED_IFORM_PHADDW_XMMdq_MEMdq=1218, + XED_IFORM_PHADDW_XMMdq_XMMdq=1219, + XED_IFORM_PHMINPOSUW_XMMdq_MEMdq=1220, + XED_IFORM_PHMINPOSUW_XMMdq_XMMdq=1221, + XED_IFORM_PHSUBD_MMXq_MEMq=1222, + XED_IFORM_PHSUBD_MMXq_MMXq=1223, + XED_IFORM_PHSUBD_XMMdq_MEMdq=1224, + XED_IFORM_PHSUBD_XMMdq_XMMdq=1225, + XED_IFORM_PHSUBSW_MMXq_MEMq=1226, + XED_IFORM_PHSUBSW_MMXq_MMXq=1227, + XED_IFORM_PHSUBSW_XMMdq_MEMdq=1228, + XED_IFORM_PHSUBSW_XMMdq_XMMdq=1229, + XED_IFORM_PHSUBW_MMXq_MEMq=1230, + XED_IFORM_PHSUBW_MMXq_MMXq=1231, + XED_IFORM_PHSUBW_XMMdq_MEMdq=1232, + XED_IFORM_PHSUBW_XMMdq_XMMdq=1233, + XED_IFORM_PI2FD_MMXq_MEMq=1234, + XED_IFORM_PI2FD_MMXq_MMXq=1235, + XED_IFORM_PI2FW_MMXq_MEMq=1236, + XED_IFORM_PI2FW_MMXq_MMXq=1237, + XED_IFORM_PINSRB_XMMdq_GPR32d_IMMb=1238, + XED_IFORM_PINSRB_XMMdq_MEMb_IMMb=1239, + XED_IFORM_PINSRD_XMMdq_GPR32d_IMMb=1240, + XED_IFORM_PINSRD_XMMdq_MEMd_IMMb=1241, + XED_IFORM_PINSRQ_XMMdq_GPR64q_IMMb=1242, + XED_IFORM_PINSRQ_XMMdq_MEMq_IMMb=1243, + XED_IFORM_PINSRW_MMXq_GPR32_IMMb=1244, + XED_IFORM_PINSRW_MMXq_MEMw_IMMb=1245, + XED_IFORM_PINSRW_XMMdq_GPR32_IMMb=1246, + XED_IFORM_PINSRW_XMMdq_MEMw_IMMb=1247, + XED_IFORM_PMADDUBSW_MMXq_MEMq=1248, + XED_IFORM_PMADDUBSW_MMXq_MMXq=1249, + XED_IFORM_PMADDUBSW_XMMdq_MEMdq=1250, + XED_IFORM_PMADDUBSW_XMMdq_XMMdq=1251, + XED_IFORM_PMADDWD_MMXq_MEMq=1252, + XED_IFORM_PMADDWD_MMXq_MMXq=1253, + XED_IFORM_PMADDWD_XMMdq_MEMdq=1254, + XED_IFORM_PMADDWD_XMMdq_XMMdq=1255, + XED_IFORM_PMAXSB_XMMdq_MEMdq=1256, + XED_IFORM_PMAXSB_XMMdq_XMMdq=1257, + XED_IFORM_PMAXSD_XMMdq_MEMdq=1258, + XED_IFORM_PMAXSD_XMMdq_XMMdq=1259, + XED_IFORM_PMAXSW_MMXq_MEMq=1260, + XED_IFORM_PMAXSW_MMXq_MMXq=1261, + XED_IFORM_PMAXSW_XMMdq_MEMdq=1262, + XED_IFORM_PMAXSW_XMMdq_XMMdq=1263, + XED_IFORM_PMAXUB_MMXq_MEMq=1264, + XED_IFORM_PMAXUB_MMXq_MMXq=1265, + XED_IFORM_PMAXUB_XMMdq_MEMdq=1266, + XED_IFORM_PMAXUB_XMMdq_XMMdq=1267, + XED_IFORM_PMAXUD_XMMdq_MEMdq=1268, + XED_IFORM_PMAXUD_XMMdq_XMMdq=1269, + XED_IFORM_PMAXUW_XMMdq_MEMdq=1270, + XED_IFORM_PMAXUW_XMMdq_XMMdq=1271, + XED_IFORM_PMINSB_XMMdq_MEMdq=1272, + XED_IFORM_PMINSB_XMMdq_XMMdq=1273, + XED_IFORM_PMINSD_XMMdq_MEMdq=1274, + XED_IFORM_PMINSD_XMMdq_XMMdq=1275, + XED_IFORM_PMINSW_MMXq_MEMq=1276, + XED_IFORM_PMINSW_MMXq_MMXq=1277, + XED_IFORM_PMINSW_XMMdq_MEMdq=1278, + XED_IFORM_PMINSW_XMMdq_XMMdq=1279, + XED_IFORM_PMINUB_MMXq_MEMq=1280, + XED_IFORM_PMINUB_MMXq_MMXq=1281, + XED_IFORM_PMINUB_XMMdq_MEMdq=1282, + XED_IFORM_PMINUB_XMMdq_XMMdq=1283, + XED_IFORM_PMINUD_XMMdq_MEMdq=1284, + XED_IFORM_PMINUD_XMMdq_XMMdq=1285, + XED_IFORM_PMINUW_XMMdq_MEMdq=1286, + XED_IFORM_PMINUW_XMMdq_XMMdq=1287, + XED_IFORM_PMOVMSKB_GPR32_MMXq=1288, + XED_IFORM_PMOVMSKB_GPR32_XMMdq=1289, + XED_IFORM_PMOVSXBD_XMMdq_MEMd=1290, + XED_IFORM_PMOVSXBD_XMMdq_XMMd=1291, + XED_IFORM_PMOVSXBQ_XMMdq_MEMw=1292, + XED_IFORM_PMOVSXBQ_XMMdq_XMMw=1293, + XED_IFORM_PMOVSXBW_XMMdq_MEMq=1294, + XED_IFORM_PMOVSXBW_XMMdq_XMMq=1295, + XED_IFORM_PMOVSXDQ_XMMdq_MEMq=1296, + XED_IFORM_PMOVSXDQ_XMMdq_XMMq=1297, + XED_IFORM_PMOVSXWD_XMMdq_MEMq=1298, + XED_IFORM_PMOVSXWD_XMMdq_XMMq=1299, + XED_IFORM_PMOVSXWQ_XMMdq_MEMd=1300, + XED_IFORM_PMOVSXWQ_XMMdq_XMMd=1301, + XED_IFORM_PMOVZXBD_XMMdq_MEMd=1302, + XED_IFORM_PMOVZXBD_XMMdq_XMMd=1303, + XED_IFORM_PMOVZXBQ_XMMdq_MEMw=1304, + XED_IFORM_PMOVZXBQ_XMMdq_XMMw=1305, + XED_IFORM_PMOVZXBW_XMMdq_MEMq=1306, + XED_IFORM_PMOVZXBW_XMMdq_XMMq=1307, + XED_IFORM_PMOVZXDQ_XMMdq_MEMq=1308, + XED_IFORM_PMOVZXDQ_XMMdq_XMMq=1309, + XED_IFORM_PMOVZXWD_XMMdq_MEMq=1310, + XED_IFORM_PMOVZXWD_XMMdq_XMMq=1311, + XED_IFORM_PMOVZXWQ_XMMdq_MEMd=1312, + XED_IFORM_PMOVZXWQ_XMMdq_XMMd=1313, + XED_IFORM_PMULDQ_XMMdq_MEMdq=1314, + XED_IFORM_PMULDQ_XMMdq_XMMdq=1315, + XED_IFORM_PMULHRSW_MMXq_MEMq=1316, + XED_IFORM_PMULHRSW_MMXq_MMXq=1317, + XED_IFORM_PMULHRSW_XMMdq_MEMdq=1318, + XED_IFORM_PMULHRSW_XMMdq_XMMdq=1319, + XED_IFORM_PMULHRW_MMXq_MEMq=1320, + XED_IFORM_PMULHRW_MMXq_MMXq=1321, + XED_IFORM_PMULHUW_MMXq_MEMq=1322, + XED_IFORM_PMULHUW_MMXq_MMXq=1323, + XED_IFORM_PMULHUW_XMMdq_MEMdq=1324, + XED_IFORM_PMULHUW_XMMdq_XMMdq=1325, + XED_IFORM_PMULHW_MMXq_MEMq=1326, + XED_IFORM_PMULHW_MMXq_MMXq=1327, + XED_IFORM_PMULHW_XMMdq_MEMdq=1328, + XED_IFORM_PMULHW_XMMdq_XMMdq=1329, + XED_IFORM_PMULLD_XMMdq_MEMdq=1330, + XED_IFORM_PMULLD_XMMdq_XMMdq=1331, + XED_IFORM_PMULLW_MMXq_MEMq=1332, + XED_IFORM_PMULLW_MMXq_MMXq=1333, + XED_IFORM_PMULLW_XMMdq_MEMdq=1334, + XED_IFORM_PMULLW_XMMdq_XMMdq=1335, + XED_IFORM_PMULUDQ_MMXq_MEMq=1336, + XED_IFORM_PMULUDQ_MMXq_MMXq=1337, + XED_IFORM_PMULUDQ_XMMdq_MEMdq=1338, + XED_IFORM_PMULUDQ_XMMdq_XMMdq=1339, + XED_IFORM_POP_DS=1340, + XED_IFORM_POP_ES=1341, + XED_IFORM_POP_FS=1342, + XED_IFORM_POP_GPRv_51=1343, + XED_IFORM_POP_GPRv_8F=1344, + XED_IFORM_POP_GS=1345, + XED_IFORM_POP_MEMv=1346, + XED_IFORM_POP_SS=1347, + XED_IFORM_POPA=1348, + XED_IFORM_POPAD=1349, + XED_IFORM_POPCNT_GPRv_GPRv=1350, + XED_IFORM_POPCNT_GPRv_MEMv=1351, + XED_IFORM_POPF=1352, + XED_IFORM_POPFD=1353, + XED_IFORM_POPFQ=1354, + XED_IFORM_POR_MMXq_MEMq=1355, + XED_IFORM_POR_MMXq_MMXq=1356, + XED_IFORM_POR_XMMdq_MEMdq=1357, + XED_IFORM_POR_XMMdq_XMMdq=1358, + XED_IFORM_PREFETCHNTA_MEMmprefetch=1359, + XED_IFORM_PREFETCHT0_MEMmprefetch=1360, + XED_IFORM_PREFETCHT1_MEMmprefetch=1361, + XED_IFORM_PREFETCHT2_MEMmprefetch=1362, + XED_IFORM_PREFETCHW_0F0Dr1=1363, + XED_IFORM_PREFETCHW_0F0Dr3=1364, + XED_IFORM_PREFETCHWT1_MEMu8=1365, + XED_IFORM_PREFETCH_EXCLUSIVE_MEMmprefetch=1366, + XED_IFORM_PREFETCH_RESERVED_0F0Dr4=1367, + XED_IFORM_PREFETCH_RESERVED_0F0Dr5=1368, + XED_IFORM_PREFETCH_RESERVED_0F0Dr6=1369, + XED_IFORM_PREFETCH_RESERVED_0F0Dr7=1370, + XED_IFORM_PSADBW_MMXq_MEMq=1371, + XED_IFORM_PSADBW_MMXq_MMXq=1372, + XED_IFORM_PSADBW_XMMdq_MEMdq=1373, + XED_IFORM_PSADBW_XMMdq_XMMdq=1374, + XED_IFORM_PSHUFB_MMXq_MEMq=1375, + XED_IFORM_PSHUFB_MMXq_MMXq=1376, + XED_IFORM_PSHUFB_XMMdq_MEMdq=1377, + XED_IFORM_PSHUFB_XMMdq_XMMdq=1378, + XED_IFORM_PSHUFD_XMMdq_MEMdq_IMMb=1379, + XED_IFORM_PSHUFD_XMMdq_XMMdq_IMMb=1380, + XED_IFORM_PSHUFHW_XMMdq_MEMdq_IMMb=1381, + XED_IFORM_PSHUFHW_XMMdq_XMMdq_IMMb=1382, + XED_IFORM_PSHUFLW_XMMdq_MEMdq_IMMb=1383, + XED_IFORM_PSHUFLW_XMMdq_XMMdq_IMMb=1384, + XED_IFORM_PSHUFW_MMXq_MEMq_IMMb=1385, + XED_IFORM_PSHUFW_MMXq_MMXq_IMMb=1386, + XED_IFORM_PSIGNB_MMXq_MEMq=1387, + XED_IFORM_PSIGNB_MMXq_MMXq=1388, + XED_IFORM_PSIGNB_XMMdq_MEMdq=1389, + XED_IFORM_PSIGNB_XMMdq_XMMdq=1390, + XED_IFORM_PSIGND_MMXq_MEMq=1391, + XED_IFORM_PSIGND_MMXq_MMXq=1392, + XED_IFORM_PSIGND_XMMdq_MEMdq=1393, + XED_IFORM_PSIGND_XMMdq_XMMdq=1394, + XED_IFORM_PSIGNW_MMXq_MEMq=1395, + XED_IFORM_PSIGNW_MMXq_MMXq=1396, + XED_IFORM_PSIGNW_XMMdq_MEMdq=1397, + XED_IFORM_PSIGNW_XMMdq_XMMdq=1398, + XED_IFORM_PSLLD_MMXq_IMMb=1399, + XED_IFORM_PSLLD_MMXq_MEMq=1400, + XED_IFORM_PSLLD_MMXq_MMXq=1401, + XED_IFORM_PSLLD_XMMdq_IMMb=1402, + XED_IFORM_PSLLD_XMMdq_MEMdq=1403, + XED_IFORM_PSLLD_XMMdq_XMMdq=1404, + XED_IFORM_PSLLDQ_XMMdq_IMMb=1405, + XED_IFORM_PSLLQ_MMXq_IMMb=1406, + XED_IFORM_PSLLQ_MMXq_MEMq=1407, + XED_IFORM_PSLLQ_MMXq_MMXq=1408, + XED_IFORM_PSLLQ_XMMdq_IMMb=1409, + XED_IFORM_PSLLQ_XMMdq_MEMdq=1410, + XED_IFORM_PSLLQ_XMMdq_XMMdq=1411, + XED_IFORM_PSLLW_MMXq_IMMb=1412, + XED_IFORM_PSLLW_MMXq_MEMq=1413, + XED_IFORM_PSLLW_MMXq_MMXq=1414, + XED_IFORM_PSLLW_XMMdq_IMMb=1415, + XED_IFORM_PSLLW_XMMdq_MEMdq=1416, + XED_IFORM_PSLLW_XMMdq_XMMdq=1417, + XED_IFORM_PSRAD_MMXq_IMMb=1418, + XED_IFORM_PSRAD_MMXq_MEMq=1419, + XED_IFORM_PSRAD_MMXq_MMXq=1420, + XED_IFORM_PSRAD_XMMdq_IMMb=1421, + XED_IFORM_PSRAD_XMMdq_MEMdq=1422, + XED_IFORM_PSRAD_XMMdq_XMMdq=1423, + XED_IFORM_PSRAW_MMXq_IMMb=1424, + XED_IFORM_PSRAW_MMXq_MEMq=1425, + XED_IFORM_PSRAW_MMXq_MMXq=1426, + XED_IFORM_PSRAW_XMMdq_IMMb=1427, + XED_IFORM_PSRAW_XMMdq_MEMdq=1428, + XED_IFORM_PSRAW_XMMdq_XMMdq=1429, + XED_IFORM_PSRLD_MMXq_IMMb=1430, + XED_IFORM_PSRLD_MMXq_MEMq=1431, + XED_IFORM_PSRLD_MMXq_MMXq=1432, + XED_IFORM_PSRLD_XMMdq_IMMb=1433, + XED_IFORM_PSRLD_XMMdq_MEMdq=1434, + XED_IFORM_PSRLD_XMMdq_XMMdq=1435, + XED_IFORM_PSRLDQ_XMMdq_IMMb=1436, + XED_IFORM_PSRLQ_MMXq_IMMb=1437, + XED_IFORM_PSRLQ_MMXq_MEMq=1438, + XED_IFORM_PSRLQ_MMXq_MMXq=1439, + XED_IFORM_PSRLQ_XMMdq_IMMb=1440, + XED_IFORM_PSRLQ_XMMdq_MEMdq=1441, + XED_IFORM_PSRLQ_XMMdq_XMMdq=1442, + XED_IFORM_PSRLW_MMXq_IMMb=1443, + XED_IFORM_PSRLW_MMXq_MEMq=1444, + XED_IFORM_PSRLW_MMXq_MMXq=1445, + XED_IFORM_PSRLW_XMMdq_IMMb=1446, + XED_IFORM_PSRLW_XMMdq_MEMdq=1447, + XED_IFORM_PSRLW_XMMdq_XMMdq=1448, + XED_IFORM_PSUBB_MMXq_MEMq=1449, + XED_IFORM_PSUBB_MMXq_MMXq=1450, + XED_IFORM_PSUBB_XMMdq_MEMdq=1451, + XED_IFORM_PSUBB_XMMdq_XMMdq=1452, + XED_IFORM_PSUBD_MMXq_MEMq=1453, + XED_IFORM_PSUBD_MMXq_MMXq=1454, + XED_IFORM_PSUBD_XMMdq_MEMdq=1455, + XED_IFORM_PSUBD_XMMdq_XMMdq=1456, + XED_IFORM_PSUBQ_MMXq_MEMq=1457, + XED_IFORM_PSUBQ_MMXq_MMXq=1458, + XED_IFORM_PSUBQ_XMMdq_MEMdq=1459, + XED_IFORM_PSUBQ_XMMdq_XMMdq=1460, + XED_IFORM_PSUBSB_MMXq_MEMq=1461, + XED_IFORM_PSUBSB_MMXq_MMXq=1462, + XED_IFORM_PSUBSB_XMMdq_MEMdq=1463, + XED_IFORM_PSUBSB_XMMdq_XMMdq=1464, + XED_IFORM_PSUBSW_MMXq_MEMq=1465, + XED_IFORM_PSUBSW_MMXq_MMXq=1466, + XED_IFORM_PSUBSW_XMMdq_MEMdq=1467, + XED_IFORM_PSUBSW_XMMdq_XMMdq=1468, + XED_IFORM_PSUBUSB_MMXq_MEMq=1469, + XED_IFORM_PSUBUSB_MMXq_MMXq=1470, + XED_IFORM_PSUBUSB_XMMdq_MEMdq=1471, + XED_IFORM_PSUBUSB_XMMdq_XMMdq=1472, + XED_IFORM_PSUBUSW_MMXq_MEMq=1473, + XED_IFORM_PSUBUSW_MMXq_MMXq=1474, + XED_IFORM_PSUBUSW_XMMdq_MEMdq=1475, + XED_IFORM_PSUBUSW_XMMdq_XMMdq=1476, + XED_IFORM_PSUBW_MMXq_MEMq=1477, + XED_IFORM_PSUBW_MMXq_MMXq=1478, + XED_IFORM_PSUBW_XMMdq_MEMdq=1479, + XED_IFORM_PSUBW_XMMdq_XMMdq=1480, + XED_IFORM_PSWAPD_MMXq_MEMq=1481, + XED_IFORM_PSWAPD_MMXq_MMXq=1482, + XED_IFORM_PTEST_XMMdq_MEMdq=1483, + XED_IFORM_PTEST_XMMdq_XMMdq=1484, + XED_IFORM_PUNPCKHBW_MMXq_MEMq=1485, + XED_IFORM_PUNPCKHBW_MMXq_MMXd=1486, + XED_IFORM_PUNPCKHBW_XMMdq_MEMdq=1487, + XED_IFORM_PUNPCKHBW_XMMdq_XMMq=1488, + XED_IFORM_PUNPCKHDQ_MMXq_MEMq=1489, + XED_IFORM_PUNPCKHDQ_MMXq_MMXd=1490, + XED_IFORM_PUNPCKHDQ_XMMdq_MEMdq=1491, + XED_IFORM_PUNPCKHDQ_XMMdq_XMMq=1492, + XED_IFORM_PUNPCKHQDQ_XMMdq_MEMdq=1493, + XED_IFORM_PUNPCKHQDQ_XMMdq_XMMq=1494, + XED_IFORM_PUNPCKHWD_MMXq_MEMq=1495, + XED_IFORM_PUNPCKHWD_MMXq_MMXd=1496, + XED_IFORM_PUNPCKHWD_XMMdq_MEMdq=1497, + XED_IFORM_PUNPCKHWD_XMMdq_XMMq=1498, + XED_IFORM_PUNPCKLBW_MMXq_MEMd=1499, + XED_IFORM_PUNPCKLBW_MMXq_MMXd=1500, + XED_IFORM_PUNPCKLBW_XMMdq_MEMdq=1501, + XED_IFORM_PUNPCKLBW_XMMdq_XMMq=1502, + XED_IFORM_PUNPCKLDQ_MMXq_MEMd=1503, + XED_IFORM_PUNPCKLDQ_MMXq_MMXd=1504, + XED_IFORM_PUNPCKLDQ_XMMdq_MEMdq=1505, + XED_IFORM_PUNPCKLDQ_XMMdq_XMMq=1506, + XED_IFORM_PUNPCKLQDQ_XMMdq_MEMdq=1507, + XED_IFORM_PUNPCKLQDQ_XMMdq_XMMq=1508, + XED_IFORM_PUNPCKLWD_MMXq_MEMd=1509, + XED_IFORM_PUNPCKLWD_MMXq_MMXd=1510, + XED_IFORM_PUNPCKLWD_XMMdq_MEMdq=1511, + XED_IFORM_PUNPCKLWD_XMMdq_XMMq=1512, + XED_IFORM_PUSH_CS=1513, + XED_IFORM_PUSH_DS=1514, + XED_IFORM_PUSH_ES=1515, + XED_IFORM_PUSH_FS=1516, + XED_IFORM_PUSH_GPRv_50=1517, + XED_IFORM_PUSH_GPRv_FFr6=1518, + XED_IFORM_PUSH_GS=1519, + XED_IFORM_PUSH_IMMb=1520, + XED_IFORM_PUSH_IMMz=1521, + XED_IFORM_PUSH_MEMv=1522, + XED_IFORM_PUSH_SS=1523, + XED_IFORM_PUSHA=1524, + XED_IFORM_PUSHAD=1525, + XED_IFORM_PUSHF=1526, + XED_IFORM_PUSHFD=1527, + XED_IFORM_PUSHFQ=1528, + XED_IFORM_PXOR_MMXq_MEMq=1529, + XED_IFORM_PXOR_MMXq_MMXq=1530, + XED_IFORM_PXOR_XMMdq_MEMdq=1531, + XED_IFORM_PXOR_XMMdq_XMMdq=1532, + XED_IFORM_RCL_GPR8_CL=1533, + XED_IFORM_RCL_GPR8_IMMb=1534, + XED_IFORM_RCL_GPR8_ONE=1535, + XED_IFORM_RCL_GPRv_CL=1536, + XED_IFORM_RCL_GPRv_IMMb=1537, + XED_IFORM_RCL_GPRv_ONE=1538, + XED_IFORM_RCL_MEMb_CL=1539, + XED_IFORM_RCL_MEMb_IMMb=1540, + XED_IFORM_RCL_MEMb_ONE=1541, + XED_IFORM_RCL_MEMv_CL=1542, + XED_IFORM_RCL_MEMv_IMMb=1543, + XED_IFORM_RCL_MEMv_ONE=1544, + XED_IFORM_RCPPS_XMMps_MEMps=1545, + XED_IFORM_RCPPS_XMMps_XMMps=1546, + XED_IFORM_RCPSS_XMMss_MEMss=1547, + XED_IFORM_RCPSS_XMMss_XMMss=1548, + XED_IFORM_RCR_GPR8_CL=1549, + XED_IFORM_RCR_GPR8_IMMb=1550, + XED_IFORM_RCR_GPR8_ONE=1551, + XED_IFORM_RCR_GPRv_CL=1552, + XED_IFORM_RCR_GPRv_IMMb=1553, + XED_IFORM_RCR_GPRv_ONE=1554, + XED_IFORM_RCR_MEMb_CL=1555, + XED_IFORM_RCR_MEMb_IMMb=1556, + XED_IFORM_RCR_MEMb_ONE=1557, + XED_IFORM_RCR_MEMv_CL=1558, + XED_IFORM_RCR_MEMv_IMMb=1559, + XED_IFORM_RCR_MEMv_ONE=1560, + XED_IFORM_RDFSBASE_GPRy=1561, + XED_IFORM_RDGSBASE_GPRy=1562, + XED_IFORM_RDMSR=1563, + XED_IFORM_RDPMC=1564, + XED_IFORM_RDRAND_GPRv=1565, + XED_IFORM_RDSEED_GPRv=1566, + XED_IFORM_RDTSC=1567, + XED_IFORM_RDTSCP=1568, + XED_IFORM_REPE_CMPSB=1569, + XED_IFORM_REPE_CMPSD=1570, + XED_IFORM_REPE_CMPSQ=1571, + XED_IFORM_REPE_CMPSW=1572, + XED_IFORM_REPE_SCASB=1573, + XED_IFORM_REPE_SCASD=1574, + XED_IFORM_REPE_SCASQ=1575, + XED_IFORM_REPE_SCASW=1576, + XED_IFORM_REPNE_CMPSB=1577, + XED_IFORM_REPNE_CMPSD=1578, + XED_IFORM_REPNE_CMPSQ=1579, + XED_IFORM_REPNE_CMPSW=1580, + XED_IFORM_REPNE_SCASB=1581, + XED_IFORM_REPNE_SCASD=1582, + XED_IFORM_REPNE_SCASQ=1583, + XED_IFORM_REPNE_SCASW=1584, + XED_IFORM_REP_INSB=1585, + XED_IFORM_REP_INSD=1586, + XED_IFORM_REP_INSW=1587, + XED_IFORM_REP_LODSB=1588, + XED_IFORM_REP_LODSD=1589, + XED_IFORM_REP_LODSQ=1590, + XED_IFORM_REP_LODSW=1591, + XED_IFORM_REP_MOVSB=1592, + XED_IFORM_REP_MOVSD=1593, + XED_IFORM_REP_MOVSQ=1594, + XED_IFORM_REP_MOVSW=1595, + XED_IFORM_REP_OUTSB=1596, + XED_IFORM_REP_OUTSD=1597, + XED_IFORM_REP_OUTSW=1598, + XED_IFORM_REP_STOSB=1599, + XED_IFORM_REP_STOSD=1600, + XED_IFORM_REP_STOSQ=1601, + XED_IFORM_REP_STOSW=1602, + XED_IFORM_RET_FAR=1603, + XED_IFORM_RET_FAR_IMMw=1604, + XED_IFORM_RET_NEAR=1605, + XED_IFORM_RET_NEAR_IMMw=1606, + XED_IFORM_ROL_GPR8_CL=1607, + XED_IFORM_ROL_GPR8_IMMb=1608, + XED_IFORM_ROL_GPR8_ONE=1609, + XED_IFORM_ROL_GPRv_CL=1610, + XED_IFORM_ROL_GPRv_IMMb=1611, + XED_IFORM_ROL_GPRv_ONE=1612, + XED_IFORM_ROL_MEMb_CL=1613, + XED_IFORM_ROL_MEMb_IMMb=1614, + XED_IFORM_ROL_MEMb_ONE=1615, + XED_IFORM_ROL_MEMv_CL=1616, + XED_IFORM_ROL_MEMv_IMMb=1617, + XED_IFORM_ROL_MEMv_ONE=1618, + XED_IFORM_ROR_GPR8_CL=1619, + XED_IFORM_ROR_GPR8_IMMb=1620, + XED_IFORM_ROR_GPR8_ONE=1621, + XED_IFORM_ROR_GPRv_CL=1622, + XED_IFORM_ROR_GPRv_IMMb=1623, + XED_IFORM_ROR_GPRv_ONE=1624, + XED_IFORM_ROR_MEMb_CL=1625, + XED_IFORM_ROR_MEMb_IMMb=1626, + XED_IFORM_ROR_MEMb_ONE=1627, + XED_IFORM_ROR_MEMv_CL=1628, + XED_IFORM_ROR_MEMv_IMMb=1629, + XED_IFORM_ROR_MEMv_ONE=1630, + XED_IFORM_RORX_VGPR32d_MEMd_IMMb=1631, + XED_IFORM_RORX_VGPR32d_VGPR32d_IMMb=1632, + XED_IFORM_RORX_VGPR64q_MEMq_IMMb=1633, + XED_IFORM_RORX_VGPR64q_VGPR64q_IMMb=1634, + XED_IFORM_ROUNDPD_XMMpd_MEMpd_IMMb=1635, + XED_IFORM_ROUNDPD_XMMpd_XMMpd_IMMb=1636, + XED_IFORM_ROUNDPS_XMMps_MEMps_IMMb=1637, + XED_IFORM_ROUNDPS_XMMps_XMMps_IMMb=1638, + XED_IFORM_ROUNDSD_XMMq_MEMq_IMMb=1639, + XED_IFORM_ROUNDSD_XMMq_XMMq_IMMb=1640, + XED_IFORM_ROUNDSS_XMMd_MEMd_IMMb=1641, + XED_IFORM_ROUNDSS_XMMd_XMMd_IMMb=1642, + XED_IFORM_RSM=1643, + XED_IFORM_RSQRTPS_XMMps_MEMps=1644, + XED_IFORM_RSQRTPS_XMMps_XMMps=1645, + XED_IFORM_RSQRTSS_XMMss_MEMss=1646, + XED_IFORM_RSQRTSS_XMMss_XMMss=1647, + XED_IFORM_SAHF=1648, + XED_IFORM_SALC=1649, + XED_IFORM_SAR_GPR8_CL=1650, + XED_IFORM_SAR_GPR8_IMMb=1651, + XED_IFORM_SAR_GPR8_ONE=1652, + XED_IFORM_SAR_GPRv_CL=1653, + XED_IFORM_SAR_GPRv_IMMb=1654, + XED_IFORM_SAR_GPRv_ONE=1655, + XED_IFORM_SAR_MEMb_CL=1656, + XED_IFORM_SAR_MEMb_IMMb=1657, + XED_IFORM_SAR_MEMb_ONE=1658, + XED_IFORM_SAR_MEMv_CL=1659, + XED_IFORM_SAR_MEMv_IMMb=1660, + XED_IFORM_SAR_MEMv_ONE=1661, + XED_IFORM_SARX_VGPR32d_MEMd_VGPR32d=1662, + XED_IFORM_SARX_VGPR32d_VGPR32d_VGPR32d=1663, + XED_IFORM_SARX_VGPR64q_MEMq_VGPR64q=1664, + XED_IFORM_SARX_VGPR64q_VGPR64q_VGPR64q=1665, + XED_IFORM_SBB_AL_IMMb=1666, + XED_IFORM_SBB_GPR8_GPR8_18=1667, + XED_IFORM_SBB_GPR8_GPR8_1A=1668, + XED_IFORM_SBB_GPR8_IMMb_80r3=1669, + XED_IFORM_SBB_GPR8_IMMb_82r3=1670, + XED_IFORM_SBB_GPR8_MEMb=1671, + XED_IFORM_SBB_GPRv_GPRv_19=1672, + XED_IFORM_SBB_GPRv_GPRv_1B=1673, + XED_IFORM_SBB_GPRv_IMMb=1674, + XED_IFORM_SBB_GPRv_IMMz=1675, + XED_IFORM_SBB_GPRv_MEMv=1676, + XED_IFORM_SBB_MEMb_GPR8=1677, + XED_IFORM_SBB_MEMb_IMMb_80r3=1678, + XED_IFORM_SBB_MEMb_IMMb_82r3=1679, + XED_IFORM_SBB_MEMv_GPRv=1680, + XED_IFORM_SBB_MEMv_IMMb=1681, + XED_IFORM_SBB_MEMv_IMMz=1682, + XED_IFORM_SBB_OrAX_IMMz=1683, + XED_IFORM_SBB_LOCK_MEMb_GPR8=1684, + XED_IFORM_SBB_LOCK_MEMb_IMMb_80r3=1685, + XED_IFORM_SBB_LOCK_MEMb_IMMb_82r3=1686, + XED_IFORM_SBB_LOCK_MEMv_GPRv=1687, + XED_IFORM_SBB_LOCK_MEMv_IMMb=1688, + XED_IFORM_SBB_LOCK_MEMv_IMMz=1689, + XED_IFORM_SCASB=1690, + XED_IFORM_SCASD=1691, + XED_IFORM_SCASQ=1692, + XED_IFORM_SCASW=1693, + XED_IFORM_SETB_GPR8=1694, + XED_IFORM_SETB_MEMb=1695, + XED_IFORM_SETBE_GPR8=1696, + XED_IFORM_SETBE_MEMb=1697, + XED_IFORM_SETL_GPR8=1698, + XED_IFORM_SETL_MEMb=1699, + XED_IFORM_SETLE_GPR8=1700, + XED_IFORM_SETLE_MEMb=1701, + XED_IFORM_SETNB_GPR8=1702, + XED_IFORM_SETNB_MEMb=1703, + XED_IFORM_SETNBE_GPR8=1704, + XED_IFORM_SETNBE_MEMb=1705, + XED_IFORM_SETNL_GPR8=1706, + XED_IFORM_SETNL_MEMb=1707, + XED_IFORM_SETNLE_GPR8=1708, + XED_IFORM_SETNLE_MEMb=1709, + XED_IFORM_SETNO_GPR8=1710, + XED_IFORM_SETNO_MEMb=1711, + XED_IFORM_SETNP_GPR8=1712, + XED_IFORM_SETNP_MEMb=1713, + XED_IFORM_SETNS_GPR8=1714, + XED_IFORM_SETNS_MEMb=1715, + XED_IFORM_SETNZ_GPR8=1716, + XED_IFORM_SETNZ_MEMb=1717, + XED_IFORM_SETO_GPR8=1718, + XED_IFORM_SETO_MEMb=1719, + XED_IFORM_SETP_GPR8=1720, + XED_IFORM_SETP_MEMb=1721, + XED_IFORM_SETS_GPR8=1722, + XED_IFORM_SETS_MEMb=1723, + XED_IFORM_SETZ_GPR8=1724, + XED_IFORM_SETZ_MEMb=1725, + XED_IFORM_SFENCE=1726, + XED_IFORM_SGDT_MEMs=1727, + XED_IFORM_SGDT_MEMs64=1728, + XED_IFORM_SHA1MSG1_XMMi32_MEMi32_SHA=1729, + XED_IFORM_SHA1MSG1_XMMi32_XMMi32_SHA=1730, + XED_IFORM_SHA1MSG2_XMMi32_MEMi32_SHA=1731, + XED_IFORM_SHA1MSG2_XMMi32_XMMi32_SHA=1732, + XED_IFORM_SHA1NEXTE_XMMi32_MEMi32_SHA=1733, + XED_IFORM_SHA1NEXTE_XMMi32_XMMi32_SHA=1734, + XED_IFORM_SHA1RNDS4_XMMi32_MEMi32_IMM8_SHA=1735, + XED_IFORM_SHA1RNDS4_XMMi32_XMMi32_IMM8_SHA=1736, + XED_IFORM_SHA256MSG1_XMMi32_MEMi32_SHA=1737, + XED_IFORM_SHA256MSG1_XMMi32_XMMi32_SHA=1738, + XED_IFORM_SHA256MSG2_XMMi32_MEMi32_SHA=1739, + XED_IFORM_SHA256MSG2_XMMi32_XMMi32_SHA=1740, + XED_IFORM_SHA256RNDS2_XMMi32_MEMi32_SHA=1741, + XED_IFORM_SHA256RNDS2_XMMi32_XMMi32_SHA=1742, + XED_IFORM_SHL_GPR8_CL_D2r4=1743, + XED_IFORM_SHL_GPR8_CL_D2r6=1744, + XED_IFORM_SHL_GPR8_IMMb_C0r4=1745, + XED_IFORM_SHL_GPR8_IMMb_C0r6=1746, + XED_IFORM_SHL_GPR8_ONE_D0r4=1747, + XED_IFORM_SHL_GPR8_ONE_D0r6=1748, + XED_IFORM_SHL_GPRv_CL_D3r4=1749, + XED_IFORM_SHL_GPRv_CL_D3r6=1750, + XED_IFORM_SHL_GPRv_IMMb_C1r4=1751, + XED_IFORM_SHL_GPRv_IMMb_C1r6=1752, + XED_IFORM_SHL_GPRv_ONE_D1r4=1753, + XED_IFORM_SHL_GPRv_ONE_D1r6=1754, + XED_IFORM_SHL_MEMb_CL_D2r4=1755, + XED_IFORM_SHL_MEMb_CL_D2r6=1756, + XED_IFORM_SHL_MEMb_IMMb_C0r4=1757, + XED_IFORM_SHL_MEMb_IMMb_C0r6=1758, + XED_IFORM_SHL_MEMb_ONE_D0r4=1759, + XED_IFORM_SHL_MEMb_ONE_D0r6=1760, + XED_IFORM_SHL_MEMv_CL_D3r4=1761, + XED_IFORM_SHL_MEMv_CL_D3r6=1762, + XED_IFORM_SHL_MEMv_IMMb_C1r4=1763, + XED_IFORM_SHL_MEMv_IMMb_C1r6=1764, + XED_IFORM_SHL_MEMv_ONE_D1r4=1765, + XED_IFORM_SHL_MEMv_ONE_D1r6=1766, + XED_IFORM_SHLD_GPRv_GPRv_CL=1767, + XED_IFORM_SHLD_GPRv_GPRv_IMMb=1768, + XED_IFORM_SHLD_MEMv_GPRv_CL=1769, + XED_IFORM_SHLD_MEMv_GPRv_IMMb=1770, + XED_IFORM_SHLX_VGPR32d_MEMd_VGPR32d=1771, + XED_IFORM_SHLX_VGPR32d_VGPR32d_VGPR32d=1772, + XED_IFORM_SHLX_VGPR64q_MEMq_VGPR64q=1773, + XED_IFORM_SHLX_VGPR64q_VGPR64q_VGPR64q=1774, + XED_IFORM_SHR_GPR8_CL=1775, + XED_IFORM_SHR_GPR8_IMMb=1776, + XED_IFORM_SHR_GPR8_ONE=1777, + XED_IFORM_SHR_GPRv_CL=1778, + XED_IFORM_SHR_GPRv_IMMb=1779, + XED_IFORM_SHR_GPRv_ONE=1780, + XED_IFORM_SHR_MEMb_CL=1781, + XED_IFORM_SHR_MEMb_IMMb=1782, + XED_IFORM_SHR_MEMb_ONE=1783, + XED_IFORM_SHR_MEMv_CL=1784, + XED_IFORM_SHR_MEMv_IMMb=1785, + XED_IFORM_SHR_MEMv_ONE=1786, + XED_IFORM_SHRD_GPRv_GPRv_CL=1787, + XED_IFORM_SHRD_GPRv_GPRv_IMMb=1788, + XED_IFORM_SHRD_MEMv_GPRv_CL=1789, + XED_IFORM_SHRD_MEMv_GPRv_IMMb=1790, + XED_IFORM_SHRX_VGPR32d_MEMd_VGPR32d=1791, + XED_IFORM_SHRX_VGPR32d_VGPR32d_VGPR32d=1792, + XED_IFORM_SHRX_VGPR64q_MEMq_VGPR64q=1793, + XED_IFORM_SHRX_VGPR64q_VGPR64q_VGPR64q=1794, + XED_IFORM_SHUFPD_XMMpd_MEMpd_IMMb=1795, + XED_IFORM_SHUFPD_XMMpd_XMMpd_IMMb=1796, + XED_IFORM_SHUFPS_XMMps_MEMps_IMMb=1797, + XED_IFORM_SHUFPS_XMMps_XMMps_IMMb=1798, + XED_IFORM_SIDT_MEMs=1799, + XED_IFORM_SIDT_MEMs64=1800, + XED_IFORM_SKINIT_EAX=1801, + XED_IFORM_SLDT_GPRv=1802, + XED_IFORM_SLDT_MEMw=1803, + XED_IFORM_SLWPCB_GPRyy=1804, + XED_IFORM_SMSW_GPRv=1805, + XED_IFORM_SMSW_MEMw=1806, + XED_IFORM_SQRTPD_XMMpd_MEMpd=1807, + XED_IFORM_SQRTPD_XMMpd_XMMpd=1808, + XED_IFORM_SQRTPS_XMMps_MEMps=1809, + XED_IFORM_SQRTPS_XMMps_XMMps=1810, + XED_IFORM_SQRTSD_XMMsd_MEMsd=1811, + XED_IFORM_SQRTSD_XMMsd_XMMsd=1812, + XED_IFORM_SQRTSS_XMMss_MEMss=1813, + XED_IFORM_SQRTSS_XMMss_XMMss=1814, + XED_IFORM_STAC=1815, + XED_IFORM_STC=1816, + XED_IFORM_STD=1817, + XED_IFORM_STGI=1818, + XED_IFORM_STI=1819, + XED_IFORM_STMXCSR_MEMd=1820, + XED_IFORM_STOSB=1821, + XED_IFORM_STOSD=1822, + XED_IFORM_STOSQ=1823, + XED_IFORM_STOSW=1824, + XED_IFORM_STR_GPRv=1825, + XED_IFORM_STR_MEMw=1826, + XED_IFORM_SUB_AL_IMMb=1827, + XED_IFORM_SUB_GPR8_GPR8_28=1828, + XED_IFORM_SUB_GPR8_GPR8_2A=1829, + XED_IFORM_SUB_GPR8_IMMb_80r5=1830, + XED_IFORM_SUB_GPR8_IMMb_82r5=1831, + XED_IFORM_SUB_GPR8_MEMb=1832, + XED_IFORM_SUB_GPRv_GPRv_29=1833, + XED_IFORM_SUB_GPRv_GPRv_2B=1834, + XED_IFORM_SUB_GPRv_IMMb=1835, + XED_IFORM_SUB_GPRv_IMMz=1836, + XED_IFORM_SUB_GPRv_MEMv=1837, + XED_IFORM_SUB_MEMb_GPR8=1838, + XED_IFORM_SUB_MEMb_IMMb_80r5=1839, + XED_IFORM_SUB_MEMb_IMMb_82r5=1840, + XED_IFORM_SUB_MEMv_GPRv=1841, + XED_IFORM_SUB_MEMv_IMMb=1842, + XED_IFORM_SUB_MEMv_IMMz=1843, + XED_IFORM_SUB_OrAX_IMMz=1844, + XED_IFORM_SUBPD_XMMpd_MEMpd=1845, + XED_IFORM_SUBPD_XMMpd_XMMpd=1846, + XED_IFORM_SUBPS_XMMps_MEMps=1847, + XED_IFORM_SUBPS_XMMps_XMMps=1848, + XED_IFORM_SUBSD_XMMsd_MEMsd=1849, + XED_IFORM_SUBSD_XMMsd_XMMsd=1850, + XED_IFORM_SUBSS_XMMss_MEMss=1851, + XED_IFORM_SUBSS_XMMss_XMMss=1852, + XED_IFORM_SUB_LOCK_MEMb_GPR8=1853, + XED_IFORM_SUB_LOCK_MEMb_IMMb_80r5=1854, + XED_IFORM_SUB_LOCK_MEMb_IMMb_82r5=1855, + XED_IFORM_SUB_LOCK_MEMv_GPRv=1856, + XED_IFORM_SUB_LOCK_MEMv_IMMb=1857, + XED_IFORM_SUB_LOCK_MEMv_IMMz=1858, + XED_IFORM_SWAPGS=1859, + XED_IFORM_SYSCALL=1860, + XED_IFORM_SYSCALL_AMD=1861, + XED_IFORM_SYSENTER=1862, + XED_IFORM_SYSEXIT=1863, + XED_IFORM_SYSRET=1864, + XED_IFORM_SYSRET_AMD=1865, + XED_IFORM_T1MSKC_GPRyy_GPRvy=1866, + XED_IFORM_T1MSKC_GPRyy_MEMy=1867, + XED_IFORM_TEST_AL_IMMb=1868, + XED_IFORM_TEST_GPR8_GPR8=1869, + XED_IFORM_TEST_GPR8_IMMb_F6r0=1870, + XED_IFORM_TEST_GPR8_IMMb_F6r1=1871, + XED_IFORM_TEST_GPRv_GPRv=1872, + XED_IFORM_TEST_GPRv_IMMz_F7r0=1873, + XED_IFORM_TEST_GPRv_IMMz_F7r1=1874, + XED_IFORM_TEST_MEMb_GPR8=1875, + XED_IFORM_TEST_MEMb_IMMb_F6r0=1876, + XED_IFORM_TEST_MEMb_IMMb_F6r1=1877, + XED_IFORM_TEST_MEMv_GPRv=1878, + XED_IFORM_TEST_MEMv_IMMz_F7r0=1879, + XED_IFORM_TEST_MEMv_IMMz_F7r1=1880, + XED_IFORM_TEST_OrAX_IMMz=1881, + XED_IFORM_TZCNT_GPRv_GPRv=1882, + XED_IFORM_TZCNT_GPRv_MEMv=1883, + XED_IFORM_TZMSK_GPRyy_GPRvy=1884, + XED_IFORM_TZMSK_GPRyy_MEMy=1885, + XED_IFORM_UCOMISD_XMMsd_MEMsd=1886, + XED_IFORM_UCOMISD_XMMsd_XMMsd=1887, + XED_IFORM_UCOMISS_XMMss_MEMss=1888, + XED_IFORM_UCOMISS_XMMss_XMMss=1889, + XED_IFORM_UD2=1890, + XED_IFORM_UNPCKHPD_XMMpd_MEMdq=1891, + XED_IFORM_UNPCKHPD_XMMpd_XMMq=1892, + XED_IFORM_UNPCKHPS_XMMps_MEMdq=1893, + XED_IFORM_UNPCKHPS_XMMps_XMMdq=1894, + XED_IFORM_UNPCKLPD_XMMpd_MEMdq=1895, + XED_IFORM_UNPCKLPD_XMMpd_XMMq=1896, + XED_IFORM_UNPCKLPS_XMMps_MEMdq=1897, + XED_IFORM_UNPCKLPS_XMMps_XMMq=1898, + XED_IFORM_VADDPD_XMMdq_XMMdq_MEMdq=1899, + XED_IFORM_VADDPD_XMMdq_XMMdq_XMMdq=1900, + XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=1901, + XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=1902, + XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=1903, + XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=1904, + XED_IFORM_VADDPD_YMMqq_YMMqq_MEMqq=1905, + XED_IFORM_VADDPD_YMMqq_YMMqq_YMMqq=1906, + XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=1907, + XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=1908, + XED_IFORM_VADDPS_XMMdq_XMMdq_MEMdq=1909, + XED_IFORM_VADDPS_XMMdq_XMMdq_XMMdq=1910, + XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=1911, + XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=1912, + XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=1913, + XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=1914, + XED_IFORM_VADDPS_YMMqq_YMMqq_MEMqq=1915, + XED_IFORM_VADDPS_YMMqq_YMMqq_YMMqq=1916, + XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=1917, + XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=1918, + XED_IFORM_VADDSD_XMMdq_XMMdq_MEMq=1919, + XED_IFORM_VADDSD_XMMdq_XMMdq_XMMq=1920, + XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=1921, + XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=1922, + XED_IFORM_VADDSS_XMMdq_XMMdq_MEMd=1923, + XED_IFORM_VADDSS_XMMdq_XMMdq_XMMd=1924, + XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=1925, + XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=1926, + XED_IFORM_VADDSUBPD_XMMdq_XMMdq_MEMdq=1927, + XED_IFORM_VADDSUBPD_XMMdq_XMMdq_XMMdq=1928, + XED_IFORM_VADDSUBPD_YMMqq_YMMqq_MEMqq=1929, + XED_IFORM_VADDSUBPD_YMMqq_YMMqq_YMMqq=1930, + XED_IFORM_VADDSUBPS_XMMdq_XMMdq_MEMdq=1931, + XED_IFORM_VADDSUBPS_XMMdq_XMMdq_XMMdq=1932, + XED_IFORM_VADDSUBPS_YMMqq_YMMqq_MEMqq=1933, + XED_IFORM_VADDSUBPS_YMMqq_YMMqq_YMMqq=1934, + XED_IFORM_VAESDEC_XMMdq_XMMdq_MEMdq=1935, + XED_IFORM_VAESDEC_XMMdq_XMMdq_XMMdq=1936, + XED_IFORM_VAESDECLAST_XMMdq_XMMdq_MEMdq=1937, + XED_IFORM_VAESDECLAST_XMMdq_XMMdq_XMMdq=1938, + XED_IFORM_VAESENC_XMMdq_XMMdq_MEMdq=1939, + XED_IFORM_VAESENC_XMMdq_XMMdq_XMMdq=1940, + XED_IFORM_VAESENCLAST_XMMdq_XMMdq_MEMdq=1941, + XED_IFORM_VAESENCLAST_XMMdq_XMMdq_XMMdq=1942, + XED_IFORM_VAESIMC_XMMdq_MEMdq=1943, + XED_IFORM_VAESIMC_XMMdq_XMMdq=1944, + XED_IFORM_VAESKEYGENASSIST_XMMdq_MEMdq_IMMb=1945, + XED_IFORM_VAESKEYGENASSIST_XMMdq_XMMdq_IMMb=1946, + XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=1947, + XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=1948, + XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=1949, + XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=1950, + XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=1951, + XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=1952, + XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=1953, + XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=1954, + XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=1955, + XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=1956, + XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=1957, + XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=1958, + XED_IFORM_VANDNPD_XMMdq_XMMdq_MEMdq=1959, + XED_IFORM_VANDNPD_XMMdq_XMMdq_XMMdq=1960, + XED_IFORM_VANDNPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=1961, + XED_IFORM_VANDNPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=1962, + XED_IFORM_VANDNPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=1963, + XED_IFORM_VANDNPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=1964, + XED_IFORM_VANDNPD_YMMqq_YMMqq_MEMqq=1965, + XED_IFORM_VANDNPD_YMMqq_YMMqq_YMMqq=1966, + XED_IFORM_VANDNPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=1967, + XED_IFORM_VANDNPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=1968, + XED_IFORM_VANDNPS_XMMdq_XMMdq_MEMdq=1969, + XED_IFORM_VANDNPS_XMMdq_XMMdq_XMMdq=1970, + XED_IFORM_VANDNPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=1971, + XED_IFORM_VANDNPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=1972, + XED_IFORM_VANDNPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=1973, + XED_IFORM_VANDNPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=1974, + XED_IFORM_VANDNPS_YMMqq_YMMqq_MEMqq=1975, + XED_IFORM_VANDNPS_YMMqq_YMMqq_YMMqq=1976, + XED_IFORM_VANDNPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=1977, + XED_IFORM_VANDNPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=1978, + XED_IFORM_VANDPD_XMMdq_XMMdq_MEMdq=1979, + XED_IFORM_VANDPD_XMMdq_XMMdq_XMMdq=1980, + XED_IFORM_VANDPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=1981, + XED_IFORM_VANDPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=1982, + XED_IFORM_VANDPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=1983, + XED_IFORM_VANDPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=1984, + XED_IFORM_VANDPD_YMMqq_YMMqq_MEMqq=1985, + XED_IFORM_VANDPD_YMMqq_YMMqq_YMMqq=1986, + XED_IFORM_VANDPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=1987, + XED_IFORM_VANDPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=1988, + XED_IFORM_VANDPS_XMMdq_XMMdq_MEMdq=1989, + XED_IFORM_VANDPS_XMMdq_XMMdq_XMMdq=1990, + XED_IFORM_VANDPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=1991, + XED_IFORM_VANDPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=1992, + XED_IFORM_VANDPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=1993, + XED_IFORM_VANDPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=1994, + XED_IFORM_VANDPS_YMMqq_YMMqq_MEMqq=1995, + XED_IFORM_VANDPS_YMMqq_YMMqq_YMMqq=1996, + XED_IFORM_VANDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=1997, + XED_IFORM_VANDPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=1998, + XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=1999, + XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2000, + XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2001, + XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2002, + XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2003, + XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2004, + XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2005, + XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2006, + XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2007, + XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2008, + XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2009, + XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2010, + XED_IFORM_VBLENDPD_XMMdq_XMMdq_MEMdq_IMMb=2011, + XED_IFORM_VBLENDPD_XMMdq_XMMdq_XMMdq_IMMb=2012, + XED_IFORM_VBLENDPD_YMMqq_YMMqq_MEMqq_IMMb=2013, + XED_IFORM_VBLENDPD_YMMqq_YMMqq_YMMqq_IMMb=2014, + XED_IFORM_VBLENDPS_XMMdq_XMMdq_MEMdq_IMMb=2015, + XED_IFORM_VBLENDPS_XMMdq_XMMdq_XMMdq_IMMb=2016, + XED_IFORM_VBLENDPS_YMMqq_YMMqq_MEMqq_IMMb=2017, + XED_IFORM_VBLENDPS_YMMqq_YMMqq_YMMqq_IMMb=2018, + XED_IFORM_VBLENDVPD_XMMdq_XMMdq_MEMdq_XMMdq=2019, + XED_IFORM_VBLENDVPD_XMMdq_XMMdq_XMMdq_XMMdq=2020, + XED_IFORM_VBLENDVPD_YMMqq_YMMqq_MEMqq_YMMqq=2021, + XED_IFORM_VBLENDVPD_YMMqq_YMMqq_YMMqq_YMMqq=2022, + XED_IFORM_VBLENDVPS_XMMdq_XMMdq_MEMdq_XMMdq=2023, + XED_IFORM_VBLENDVPS_XMMdq_XMMdq_XMMdq_XMMdq=2024, + XED_IFORM_VBLENDVPS_YMMqq_YMMqq_MEMqq_YMMqq=2025, + XED_IFORM_VBLENDVPS_YMMqq_YMMqq_YMMqq_YMMqq=2026, + XED_IFORM_VBROADCASTF128_YMMqq_MEMdq=2027, + XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_MEMf32_AVX512=2028, + XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_XMMf32_AVX512=2029, + XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_MEMf32_AVX512=2030, + XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_XMMf32_AVX512=2031, + XED_IFORM_VBROADCASTF32X4_YMMf32_MASKmskw_MEMf32_AVX512=2032, + XED_IFORM_VBROADCASTF32X4_ZMMf32_MASKmskw_MEMf32_AVX512=2033, + XED_IFORM_VBROADCASTF32X8_ZMMf32_MASKmskw_MEMf32_AVX512=2034, + XED_IFORM_VBROADCASTF64X2_YMMf64_MASKmskw_MEMf64_AVX512=2035, + XED_IFORM_VBROADCASTF64X2_ZMMf64_MASKmskw_MEMf64_AVX512=2036, + XED_IFORM_VBROADCASTF64X4_ZMMf64_MASKmskw_MEMf64_AVX512=2037, + XED_IFORM_VBROADCASTI128_YMMqq_MEMdq=2038, + XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_MEMu32_AVX512=2039, + XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_XMMu32_AVX512=2040, + XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_MEMu32_AVX512=2041, + XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_XMMu32_AVX512=2042, + XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_MEMu32_AVX512=2043, + XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_XMMu32_AVX512=2044, + XED_IFORM_VBROADCASTI32X4_YMMu32_MASKmskw_MEMu32_AVX512=2045, + XED_IFORM_VBROADCASTI32X4_ZMMu32_MASKmskw_MEMu32_AVX512=2046, + XED_IFORM_VBROADCASTI32X8_ZMMu32_MASKmskw_MEMu32_AVX512=2047, + XED_IFORM_VBROADCASTI64X2_YMMu64_MASKmskw_MEMu64_AVX512=2048, + XED_IFORM_VBROADCASTI64X2_ZMMu64_MASKmskw_MEMu64_AVX512=2049, + XED_IFORM_VBROADCASTI64X4_ZMMu64_MASKmskw_MEMu64_AVX512=2050, + XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_MEMf64_AVX512=2051, + XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_XMMf64_AVX512=2052, + XED_IFORM_VBROADCASTSD_YMMqq_MEMq=2053, + XED_IFORM_VBROADCASTSD_YMMqq_XMMdq=2054, + XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_MEMf64_AVX512=2055, + XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_XMMf64_AVX512=2056, + XED_IFORM_VBROADCASTSS_XMMdq_MEMd=2057, + XED_IFORM_VBROADCASTSS_XMMdq_XMMdq=2058, + XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_MEMf32_AVX512=2059, + XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_XMMf32_AVX512=2060, + XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_MEMf32_AVX512=2061, + XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_XMMf32_AVX512=2062, + XED_IFORM_VBROADCASTSS_YMMqq_MEMd=2063, + XED_IFORM_VBROADCASTSS_YMMqq_XMMdq=2064, + XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_MEMf32_AVX512=2065, + XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_XMMf32_AVX512=2066, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2067, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2068, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=2069, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=2070, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=2071, + XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=2072, + XED_IFORM_VCMPPD_XMMdq_XMMdq_MEMdq_IMMb=2073, + XED_IFORM_VCMPPD_XMMdq_XMMdq_XMMdq_IMMb=2074, + XED_IFORM_VCMPPD_YMMqq_YMMqq_MEMqq_IMMb=2075, + XED_IFORM_VCMPPD_YMMqq_YMMqq_YMMqq_IMMb=2076, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2077, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2078, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=2079, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=2080, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=2081, + XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=2082, + XED_IFORM_VCMPPS_XMMdq_XMMdq_MEMdq_IMMb=2083, + XED_IFORM_VCMPPS_XMMdq_XMMdq_XMMdq_IMMb=2084, + XED_IFORM_VCMPPS_YMMqq_YMMqq_MEMqq_IMMb=2085, + XED_IFORM_VCMPPS_YMMqq_YMMqq_YMMqq_IMMb=2086, + XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2087, + XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2088, + XED_IFORM_VCMPSD_XMMdq_XMMdq_MEMq_IMMb=2089, + XED_IFORM_VCMPSD_XMMdq_XMMdq_XMMq_IMMb=2090, + XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2091, + XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2092, + XED_IFORM_VCMPSS_XMMdq_XMMdq_MEMd_IMMb=2093, + XED_IFORM_VCMPSS_XMMdq_XMMdq_XMMd_IMMb=2094, + XED_IFORM_VCOMISD_XMMf64_MEMf64_AVX512=2095, + XED_IFORM_VCOMISD_XMMf64_XMMf64_AVX512=2096, + XED_IFORM_VCOMISD_XMMq_MEMq=2097, + XED_IFORM_VCOMISD_XMMq_XMMq=2098, + XED_IFORM_VCOMISS_XMMd_MEMd=2099, + XED_IFORM_VCOMISS_XMMd_XMMd=2100, + XED_IFORM_VCOMISS_XMMf32_MEMf32_AVX512=2101, + XED_IFORM_VCOMISS_XMMf32_XMMf32_AVX512=2102, + XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_XMMf64_AVX512=2103, + XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_YMMf64_AVX512=2104, + XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_ZMMf64_AVX512=2105, + XED_IFORM_VCOMPRESSPD_XMMf64_MASKmskw_XMMf64_AVX512=2106, + XED_IFORM_VCOMPRESSPD_YMMf64_MASKmskw_YMMf64_AVX512=2107, + XED_IFORM_VCOMPRESSPD_ZMMf64_MASKmskw_ZMMf64_AVX512=2108, + XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_XMMf32_AVX512=2109, + XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_YMMf32_AVX512=2110, + XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_ZMMf32_AVX512=2111, + XED_IFORM_VCOMPRESSPS_XMMf32_MASKmskw_XMMf32_AVX512=2112, + XED_IFORM_VCOMPRESSPS_YMMf32_MASKmskw_YMMf32_AVX512=2113, + XED_IFORM_VCOMPRESSPS_ZMMf32_MASKmskw_ZMMf32_AVX512=2114, + XED_IFORM_VCVTDQ2PD_XMMdq_MEMq=2115, + XED_IFORM_VCVTDQ2PD_XMMdq_XMMq=2116, + XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_MEMi32_AVX512=2117, + XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_XMMi32_AVX512=2118, + XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_MEMi32_AVX512=2119, + XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_XMMi32_AVX512=2120, + XED_IFORM_VCVTDQ2PD_YMMqq_MEMdq=2121, + XED_IFORM_VCVTDQ2PD_YMMqq_XMMdq=2122, + XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_MEMi32_AVX512=2123, + XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_YMMi32_AVX512=2124, + XED_IFORM_VCVTDQ2PS_XMMdq_MEMdq=2125, + XED_IFORM_VCVTDQ2PS_XMMdq_XMMdq=2126, + XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_MEMi32_AVX512=2127, + XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_XMMi32_AVX512=2128, + XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_MEMi32_AVX512=2129, + XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_YMMi32_AVX512=2130, + XED_IFORM_VCVTDQ2PS_YMMqq_MEMqq=2131, + XED_IFORM_VCVTDQ2PS_YMMqq_YMMqq=2132, + XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_MEMi32_AVX512=2133, + XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_ZMMi32_AVX512=2134, + XED_IFORM_VCVTPD2DQ_XMMdq_MEMdq=2135, + XED_IFORM_VCVTPD2DQ_XMMdq_MEMqq=2136, + XED_IFORM_VCVTPD2DQ_XMMdq_XMMdq=2137, + XED_IFORM_VCVTPD2DQ_XMMdq_YMMqq=2138, + XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128=2139, + XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256=2140, + XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128=2141, + XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256=2142, + XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512=2143, + XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512=2144, + XED_IFORM_VCVTPD2PS_XMMdq_MEMdq=2145, + XED_IFORM_VCVTPD2PS_XMMdq_MEMqq=2146, + XED_IFORM_VCVTPD2PS_XMMdq_XMMdq=2147, + XED_IFORM_VCVTPD2PS_XMMdq_YMMqq=2148, + XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL128=2149, + XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL256=2150, + XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_XMMf64_AVX512_VL128=2151, + XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_YMMf64_AVX512_VL256=2152, + XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_MEMf64_AVX512_VL512=2153, + XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_ZMMf64_AVX512_VL512=2154, + XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512=2155, + XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512=2156, + XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512=2157, + XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512=2158, + XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512=2159, + XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512=2160, + XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128=2161, + XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256=2162, + XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128=2163, + XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256=2164, + XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512=2165, + XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512=2166, + XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512=2167, + XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512=2168, + XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512=2169, + XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512=2170, + XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512=2171, + XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512=2172, + XED_IFORM_VCVTPH2PS_XMMdq_MEMq=2173, + XED_IFORM_VCVTPH2PS_XMMdq_XMMq=2174, + XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_MEMf16_AVX512=2175, + XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_XMMf16_AVX512=2176, + XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_MEMf16_AVX512=2177, + XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_XMMf16_AVX512=2178, + XED_IFORM_VCVTPH2PS_YMMqq_MEMdq=2179, + XED_IFORM_VCVTPH2PS_YMMqq_XMMdq=2180, + XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_MEMf16_AVX512=2181, + XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_YMMf16_AVX512=2182, + XED_IFORM_VCVTPS2DQ_XMMdq_MEMdq=2183, + XED_IFORM_VCVTPS2DQ_XMMdq_XMMdq=2184, + XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512=2185, + XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512=2186, + XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512=2187, + XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512=2188, + XED_IFORM_VCVTPS2DQ_YMMqq_MEMqq=2189, + XED_IFORM_VCVTPS2DQ_YMMqq_YMMqq=2190, + XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512=2191, + XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512=2192, + XED_IFORM_VCVTPS2PD_XMMdq_MEMq=2193, + XED_IFORM_VCVTPS2PD_XMMdq_XMMq=2194, + XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_MEMf32_AVX512=2195, + XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_XMMf32_AVX512=2196, + XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_MEMf32_AVX512=2197, + XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_XMMf32_AVX512=2198, + XED_IFORM_VCVTPS2PD_YMMqq_MEMdq=2199, + XED_IFORM_VCVTPS2PD_YMMqq_XMMdq=2200, + XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_MEMf32_AVX512=2201, + XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_YMMf32_AVX512=2202, + XED_IFORM_VCVTPS2PH_MEMdq_YMMqq_IMMb=2203, + XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_XMMf32_IMM8_AVX512=2204, + XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_YMMf32_IMM8_AVX512=2205, + XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_ZMMf32_IMM8_AVX512=2206, + XED_IFORM_VCVTPS2PH_MEMq_XMMdq_IMMb=2207, + XED_IFORM_VCVTPS2PH_XMMdq_YMMqq_IMMb=2208, + XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_XMMf32_IMM8_AVX512=2209, + XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_YMMf32_IMM8_AVX512=2210, + XED_IFORM_VCVTPS2PH_XMMq_XMMdq_IMMb=2211, + XED_IFORM_VCVTPS2PH_YMMf16_MASKmskw_ZMMf32_IMM8_AVX512=2212, + XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512=2213, + XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512=2214, + XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512=2215, + XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512=2216, + XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512=2217, + XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512=2218, + XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512=2219, + XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512=2220, + XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512=2221, + XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512=2222, + XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512=2223, + XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512=2224, + XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512=2225, + XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512=2226, + XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512=2227, + XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512=2228, + XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512=2229, + XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512=2230, + XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_MEMf64_AVX512=2231, + XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_XMMf64_AVX512=2232, + XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_MEMf64_AVX512=2233, + XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_YMMf64_AVX512=2234, + XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_MEMf64_AVX512=2235, + XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_ZMMf64_AVX512=2236, + XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128=2237, + XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256=2238, + XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128=2239, + XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256=2240, + XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512=2241, + XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512=2242, + XED_IFORM_VCVTSD2SI_GPR32d_MEMq=2243, + XED_IFORM_VCVTSD2SI_GPR32d_XMMq=2244, + XED_IFORM_VCVTSD2SI_GPR32i32_MEMf64_AVX512=2245, + XED_IFORM_VCVTSD2SI_GPR32i32_XMMf64_AVX512=2246, + XED_IFORM_VCVTSD2SI_GPR64i64_MEMf64_AVX512=2247, + XED_IFORM_VCVTSD2SI_GPR64i64_XMMf64_AVX512=2248, + XED_IFORM_VCVTSD2SI_GPR64q_MEMq=2249, + XED_IFORM_VCVTSD2SI_GPR64q_XMMq=2250, + XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_MEMq=2251, + XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_XMMq=2252, + XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_MEMf64_AVX512=2253, + XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_XMMf64_AVX512=2254, + XED_IFORM_VCVTSD2USI_GPR32u32_MEMf64_AVX512=2255, + XED_IFORM_VCVTSD2USI_GPR32u32_XMMf64_AVX512=2256, + XED_IFORM_VCVTSD2USI_GPR64u64_MEMf64_AVX512=2257, + XED_IFORM_VCVTSD2USI_GPR64u64_XMMf64_AVX512=2258, + XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR32d=2259, + XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR64q=2260, + XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMd=2261, + XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMq=2262, + XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR32i32_AVX512=2263, + XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR64i64_AVX512=2264, + XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi32_AVX512=2265, + XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi64_AVX512=2266, + XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR32d=2267, + XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR64q=2268, + XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMd=2269, + XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMq=2270, + XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR32i32_AVX512=2271, + XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR64i64_AVX512=2272, + XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi32_AVX512=2273, + XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi64_AVX512=2274, + XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_MEMd=2275, + XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_XMMd=2276, + XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_MEMf32_AVX512=2277, + XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_XMMf32_AVX512=2278, + XED_IFORM_VCVTSS2SI_GPR32d_MEMd=2279, + XED_IFORM_VCVTSS2SI_GPR32d_XMMd=2280, + XED_IFORM_VCVTSS2SI_GPR32i32_MEMf32_AVX512=2281, + XED_IFORM_VCVTSS2SI_GPR32i32_XMMf32_AVX512=2282, + XED_IFORM_VCVTSS2SI_GPR64i64_MEMf32_AVX512=2283, + XED_IFORM_VCVTSS2SI_GPR64i64_XMMf32_AVX512=2284, + XED_IFORM_VCVTSS2SI_GPR64q_MEMd=2285, + XED_IFORM_VCVTSS2SI_GPR64q_XMMd=2286, + XED_IFORM_VCVTSS2USI_GPR32u32_MEMf32_AVX512=2287, + XED_IFORM_VCVTSS2USI_GPR32u32_XMMf32_AVX512=2288, + XED_IFORM_VCVTSS2USI_GPR64u64_MEMf32_AVX512=2289, + XED_IFORM_VCVTSS2USI_GPR64u64_XMMf32_AVX512=2290, + XED_IFORM_VCVTTPD2DQ_XMMdq_MEMdq=2291, + XED_IFORM_VCVTTPD2DQ_XMMdq_MEMqq=2292, + XED_IFORM_VCVTTPD2DQ_XMMdq_XMMdq=2293, + XED_IFORM_VCVTTPD2DQ_XMMdq_YMMqq=2294, + XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128=2295, + XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256=2296, + XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128=2297, + XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256=2298, + XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512=2299, + XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512=2300, + XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512=2301, + XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512=2302, + XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512=2303, + XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512=2304, + XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512=2305, + XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512=2306, + XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128=2307, + XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256=2308, + XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128=2309, + XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256=2310, + XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512=2311, + XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512=2312, + XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512=2313, + XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512=2314, + XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512=2315, + XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512=2316, + XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512=2317, + XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512=2318, + XED_IFORM_VCVTTPS2DQ_XMMdq_MEMdq=2319, + XED_IFORM_VCVTTPS2DQ_XMMdq_XMMdq=2320, + XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512=2321, + XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512=2322, + XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512=2323, + XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512=2324, + XED_IFORM_VCVTTPS2DQ_YMMqq_MEMqq=2325, + XED_IFORM_VCVTTPS2DQ_YMMqq_YMMqq=2326, + XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512=2327, + XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512=2328, + XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512=2329, + XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512=2330, + XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512=2331, + XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512=2332, + XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512=2333, + XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512=2334, + XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512=2335, + XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512=2336, + XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512=2337, + XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512=2338, + XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512=2339, + XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512=2340, + XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512=2341, + XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512=2342, + XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512=2343, + XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512=2344, + XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512=2345, + XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512=2346, + XED_IFORM_VCVTTSD2SI_GPR32d_MEMq=2347, + XED_IFORM_VCVTTSD2SI_GPR32d_XMMq=2348, + XED_IFORM_VCVTTSD2SI_GPR32i32_MEMf64_AVX512=2349, + XED_IFORM_VCVTTSD2SI_GPR32i32_XMMf64_AVX512=2350, + XED_IFORM_VCVTTSD2SI_GPR64i64_MEMf64_AVX512=2351, + XED_IFORM_VCVTTSD2SI_GPR64i64_XMMf64_AVX512=2352, + XED_IFORM_VCVTTSD2SI_GPR64q_MEMq=2353, + XED_IFORM_VCVTTSD2SI_GPR64q_XMMq=2354, + XED_IFORM_VCVTTSD2USI_GPR32u32_MEMf64_AVX512=2355, + XED_IFORM_VCVTTSD2USI_GPR32u32_XMMf64_AVX512=2356, + XED_IFORM_VCVTTSD2USI_GPR64u64_MEMf64_AVX512=2357, + XED_IFORM_VCVTTSD2USI_GPR64u64_XMMf64_AVX512=2358, + XED_IFORM_VCVTTSS2SI_GPR32d_MEMd=2359, + XED_IFORM_VCVTTSS2SI_GPR32d_XMMd=2360, + XED_IFORM_VCVTTSS2SI_GPR32i32_MEMf32_AVX512=2361, + XED_IFORM_VCVTTSS2SI_GPR32i32_XMMf32_AVX512=2362, + XED_IFORM_VCVTTSS2SI_GPR64i64_MEMf32_AVX512=2363, + XED_IFORM_VCVTTSS2SI_GPR64i64_XMMf32_AVX512=2364, + XED_IFORM_VCVTTSS2SI_GPR64q_MEMd=2365, + XED_IFORM_VCVTTSS2SI_GPR64q_XMMd=2366, + XED_IFORM_VCVTTSS2USI_GPR32u32_MEMf32_AVX512=2367, + XED_IFORM_VCVTTSS2USI_GPR32u32_XMMf32_AVX512=2368, + XED_IFORM_VCVTTSS2USI_GPR64u64_MEMf32_AVX512=2369, + XED_IFORM_VCVTTSS2USI_GPR64u64_XMMf32_AVX512=2370, + XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_MEMu32_AVX512=2371, + XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_XMMu32_AVX512=2372, + XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_MEMu32_AVX512=2373, + XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_XMMu32_AVX512=2374, + XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_MEMu32_AVX512=2375, + XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_YMMu32_AVX512=2376, + XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_MEMu32_AVX512=2377, + XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_XMMu32_AVX512=2378, + XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_MEMu32_AVX512=2379, + XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_YMMu32_AVX512=2380, + XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_MEMu32_AVX512=2381, + XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_ZMMu32_AVX512=2382, + XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_MEMu64_AVX512=2383, + XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_XMMu64_AVX512=2384, + XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_MEMu64_AVX512=2385, + XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_YMMu64_AVX512=2386, + XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_MEMu64_AVX512=2387, + XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_ZMMu64_AVX512=2388, + XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128=2389, + XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256=2390, + XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128=2391, + XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256=2392, + XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512=2393, + XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512=2394, + XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR32u32_AVX512=2395, + XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR64u64_AVX512=2396, + XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu32_AVX512=2397, + XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu64_AVX512=2398, + XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR32u32_AVX512=2399, + XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR64u64_AVX512=2400, + XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu32_AVX512=2401, + XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu64_AVX512=2402, + XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=2403, + XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=2404, + XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=2405, + XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=2406, + XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=2407, + XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=2408, + XED_IFORM_VDIVPD_XMMdq_XMMdq_MEMdq=2409, + XED_IFORM_VDIVPD_XMMdq_XMMdq_XMMdq=2410, + XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2411, + XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2412, + XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2413, + XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2414, + XED_IFORM_VDIVPD_YMMqq_YMMqq_MEMqq=2415, + XED_IFORM_VDIVPD_YMMqq_YMMqq_YMMqq=2416, + XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2417, + XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2418, + XED_IFORM_VDIVPS_XMMdq_XMMdq_MEMdq=2419, + XED_IFORM_VDIVPS_XMMdq_XMMdq_XMMdq=2420, + XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2421, + XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2422, + XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2423, + XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2424, + XED_IFORM_VDIVPS_YMMqq_YMMqq_MEMqq=2425, + XED_IFORM_VDIVPS_YMMqq_YMMqq_YMMqq=2426, + XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2427, + XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2428, + XED_IFORM_VDIVSD_XMMdq_XMMdq_MEMq=2429, + XED_IFORM_VDIVSD_XMMdq_XMMdq_XMMq=2430, + XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2431, + XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2432, + XED_IFORM_VDIVSS_XMMdq_XMMdq_MEMd=2433, + XED_IFORM_VDIVSS_XMMdq_XMMdq_XMMd=2434, + XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2435, + XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2436, + XED_IFORM_VDPPD_XMMdq_XMMdq_MEMdq_IMMb=2437, + XED_IFORM_VDPPD_XMMdq_XMMdq_XMMdq_IMMb=2438, + XED_IFORM_VDPPS_XMMdq_XMMdq_MEMdq_IMMb=2439, + XED_IFORM_VDPPS_XMMdq_XMMdq_XMMdq_IMMb=2440, + XED_IFORM_VDPPS_YMMqq_YMMqq_MEMqq_IMMb=2441, + XED_IFORM_VDPPS_YMMqq_YMMqq_YMMqq_IMMb=2442, + XED_IFORM_VERR_GPR16=2443, + XED_IFORM_VERR_MEMw=2444, + XED_IFORM_VERW_GPR16=2445, + XED_IFORM_VERW_MEMw=2446, + XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=2447, + XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=2448, + XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=2449, + XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=2450, + XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_MEMf64_AVX512=2451, + XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_XMMf64_AVX512=2452, + XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_MEMf64_AVX512=2453, + XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_YMMf64_AVX512=2454, + XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_MEMf64_AVX512=2455, + XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_ZMMf64_AVX512=2456, + XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_MEMf32_AVX512=2457, + XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_XMMf32_AVX512=2458, + XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_MEMf32_AVX512=2459, + XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_YMMf32_AVX512=2460, + XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_MEMf32_AVX512=2461, + XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_ZMMf32_AVX512=2462, + XED_IFORM_VEXTRACTF128_MEMdq_YMMdq_IMMb=2463, + XED_IFORM_VEXTRACTF128_XMMdq_YMMdq_IMMb=2464, + XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_YMMf32_IMM8_AVX512=2465, + XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512=2466, + XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_YMMf32_IMM8_AVX512=2467, + XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_ZMMf32_IMM8_AVX512=2468, + XED_IFORM_VEXTRACTF32X8_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512=2469, + XED_IFORM_VEXTRACTF32X8_YMMf32_MASKmskw_ZMMf32_IMM8_AVX512=2470, + XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_YMMf64_IMM8_AVX512=2471, + XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512=2472, + XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_YMMf64_IMM8_AVX512=2473, + XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_ZMMf64_IMM8_AVX512=2474, + XED_IFORM_VEXTRACTF64X4_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512=2475, + XED_IFORM_VEXTRACTF64X4_YMMf64_MASKmskw_ZMMf64_IMM8_AVX512=2476, + XED_IFORM_VEXTRACTI128_MEMdq_YMMqq_IMMb=2477, + XED_IFORM_VEXTRACTI128_XMMdq_YMMqq_IMMb=2478, + XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_YMMu32_IMM8_AVX512=2479, + XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512=2480, + XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_YMMu32_IMM8_AVX512=2481, + XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_ZMMu32_IMM8_AVX512=2482, + XED_IFORM_VEXTRACTI32X8_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512=2483, + XED_IFORM_VEXTRACTI32X8_YMMu32_MASKmskw_ZMMu32_IMM8_AVX512=2484, + XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_YMMu64_IMM8_AVX512=2485, + XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512=2486, + XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_YMMu64_IMM8_AVX512=2487, + XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_ZMMu64_IMM8_AVX512=2488, + XED_IFORM_VEXTRACTI64X4_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512=2489, + XED_IFORM_VEXTRACTI64X4_YMMu64_MASKmskw_ZMMu64_IMM8_AVX512=2490, + XED_IFORM_VEXTRACTPS_GPR32_XMMdq_IMMb=2491, + XED_IFORM_VEXTRACTPS_GPR32f32_XMMf32_IMM8_AVX512=2492, + XED_IFORM_VEXTRACTPS_MEMd_XMMdq_IMMb=2493, + XED_IFORM_VEXTRACTPS_MEMf32_XMMf32_IMM8_AVX512=2494, + XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2495, + XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2496, + XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=2497, + XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=2498, + XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=2499, + XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=2500, + XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2501, + XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2502, + XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=2503, + XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=2504, + XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=2505, + XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=2506, + XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2507, + XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2508, + XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2509, + XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2510, + XED_IFORM_VFMADD132PD_XMMdq_XMMdq_MEMdq=2511, + XED_IFORM_VFMADD132PD_XMMdq_XMMdq_XMMdq=2512, + XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2513, + XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2514, + XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2515, + XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2516, + XED_IFORM_VFMADD132PD_YMMqq_YMMqq_MEMqq=2517, + XED_IFORM_VFMADD132PD_YMMqq_YMMqq_YMMqq=2518, + XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2519, + XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2520, + XED_IFORM_VFMADD132PS_XMMdq_XMMdq_MEMdq=2521, + XED_IFORM_VFMADD132PS_XMMdq_XMMdq_XMMdq=2522, + XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2523, + XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2524, + XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2525, + XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2526, + XED_IFORM_VFMADD132PS_YMMqq_YMMqq_MEMqq=2527, + XED_IFORM_VFMADD132PS_YMMqq_YMMqq_YMMqq=2528, + XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2529, + XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2530, + XED_IFORM_VFMADD132SD_XMMdq_XMMq_MEMq=2531, + XED_IFORM_VFMADD132SD_XMMdq_XMMq_XMMq=2532, + XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2533, + XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2534, + XED_IFORM_VFMADD132SS_XMMdq_XMMd_MEMd=2535, + XED_IFORM_VFMADD132SS_XMMdq_XMMd_XMMd=2536, + XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2537, + XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2538, + XED_IFORM_VFMADD213PD_XMMdq_XMMdq_MEMdq=2539, + XED_IFORM_VFMADD213PD_XMMdq_XMMdq_XMMdq=2540, + XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2541, + XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2542, + XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2543, + XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2544, + XED_IFORM_VFMADD213PD_YMMqq_YMMqq_MEMqq=2545, + XED_IFORM_VFMADD213PD_YMMqq_YMMqq_YMMqq=2546, + XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2547, + XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2548, + XED_IFORM_VFMADD213PS_XMMdq_XMMdq_MEMdq=2549, + XED_IFORM_VFMADD213PS_XMMdq_XMMdq_XMMdq=2550, + XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2551, + XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2552, + XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2553, + XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2554, + XED_IFORM_VFMADD213PS_YMMqq_YMMqq_MEMqq=2555, + XED_IFORM_VFMADD213PS_YMMqq_YMMqq_YMMqq=2556, + XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2557, + XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2558, + XED_IFORM_VFMADD213SD_XMMdq_XMMq_MEMq=2559, + XED_IFORM_VFMADD213SD_XMMdq_XMMq_XMMq=2560, + XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2561, + XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2562, + XED_IFORM_VFMADD213SS_XMMdq_XMMd_MEMd=2563, + XED_IFORM_VFMADD213SS_XMMdq_XMMd_XMMd=2564, + XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2565, + XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2566, + XED_IFORM_VFMADD231PD_XMMdq_XMMdq_MEMdq=2567, + XED_IFORM_VFMADD231PD_XMMdq_XMMdq_XMMdq=2568, + XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2569, + XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2570, + XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2571, + XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2572, + XED_IFORM_VFMADD231PD_YMMqq_YMMqq_MEMqq=2573, + XED_IFORM_VFMADD231PD_YMMqq_YMMqq_YMMqq=2574, + XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2575, + XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2576, + XED_IFORM_VFMADD231PS_XMMdq_XMMdq_MEMdq=2577, + XED_IFORM_VFMADD231PS_XMMdq_XMMdq_XMMdq=2578, + XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2579, + XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2580, + XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2581, + XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2582, + XED_IFORM_VFMADD231PS_YMMqq_YMMqq_MEMqq=2583, + XED_IFORM_VFMADD231PS_YMMqq_YMMqq_YMMqq=2584, + XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2585, + XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2586, + XED_IFORM_VFMADD231SD_XMMdq_XMMq_MEMq=2587, + XED_IFORM_VFMADD231SD_XMMdq_XMMq_XMMq=2588, + XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2589, + XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2590, + XED_IFORM_VFMADD231SS_XMMdq_XMMd_MEMd=2591, + XED_IFORM_VFMADD231SS_XMMdq_XMMd_XMMd=2592, + XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2593, + XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2594, + XED_IFORM_VFMADDPD_XMMdq_XMMdq_MEMdq_XMMdq=2595, + XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_MEMdq=2596, + XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_XMMdq=2597, + XED_IFORM_VFMADDPD_YMMqq_YMMqq_MEMqq_YMMqq=2598, + XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_MEMqq=2599, + XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_YMMqq=2600, + XED_IFORM_VFMADDPS_XMMdq_XMMdq_MEMdq_XMMdq=2601, + XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_MEMdq=2602, + XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_XMMdq=2603, + XED_IFORM_VFMADDPS_YMMqq_YMMqq_MEMqq_YMMqq=2604, + XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_MEMqq=2605, + XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_YMMqq=2606, + XED_IFORM_VFMADDSD_XMMdq_XMMdq_MEMq_XMMdq=2607, + XED_IFORM_VFMADDSD_XMMdq_XMMdq_XMMdq_MEMq=2608, + XED_IFORM_VFMADDSD_XMMdq_XMMdq_XMMdq_XMMq=2609, + XED_IFORM_VFMADDSD_XMMdq_XMMdq_XMMq_XMMdq=2610, + XED_IFORM_VFMADDSS_XMMdq_XMMdq_MEMd_XMMdq=2611, + XED_IFORM_VFMADDSS_XMMdq_XMMdq_XMMd_XMMdq=2612, + XED_IFORM_VFMADDSS_XMMdq_XMMdq_XMMdq_MEMd=2613, + XED_IFORM_VFMADDSS_XMMdq_XMMdq_XMMdq_XMMd=2614, + XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_MEMdq=2615, + XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_XMMdq=2616, + XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2617, + XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2618, + XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2619, + XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2620, + XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_MEMqq=2621, + XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_YMMqq=2622, + XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2623, + XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2624, + XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_MEMdq=2625, + XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_XMMdq=2626, + XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2627, + XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2628, + XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2629, + XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2630, + XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_MEMqq=2631, + XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_YMMqq=2632, + XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2633, + XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2634, + XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_MEMdq=2635, + XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_XMMdq=2636, + XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2637, + XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2638, + XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2639, + XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2640, + XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_MEMqq=2641, + XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_YMMqq=2642, + XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2643, + XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2644, + XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_MEMdq=2645, + XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_XMMdq=2646, + XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2647, + XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2648, + XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2649, + XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2650, + XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_MEMqq=2651, + XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_YMMqq=2652, + XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2653, + XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2654, + XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_MEMdq=2655, + XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_XMMdq=2656, + XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2657, + XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2658, + XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2659, + XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2660, + XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_MEMqq=2661, + XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_YMMqq=2662, + XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2663, + XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2664, + XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_MEMdq=2665, + XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_XMMdq=2666, + XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2667, + XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2668, + XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2669, + XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2670, + XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_MEMqq=2671, + XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_YMMqq=2672, + XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2673, + XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2674, + XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=2675, + XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=2676, + XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=2677, + XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=2678, + XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=2679, + XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=2680, + XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=2681, + XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=2682, + XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=2683, + XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=2684, + XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=2685, + XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=2686, + XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_MEMdq=2687, + XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_XMMdq=2688, + XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2689, + XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2690, + XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2691, + XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2692, + XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_MEMqq=2693, + XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_YMMqq=2694, + XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2695, + XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2696, + XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_MEMdq=2697, + XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_XMMdq=2698, + XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2699, + XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2700, + XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2701, + XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2702, + XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_MEMqq=2703, + XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_YMMqq=2704, + XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2705, + XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2706, + XED_IFORM_VFMSUB132SD_XMMdq_XMMq_MEMq=2707, + XED_IFORM_VFMSUB132SD_XMMdq_XMMq_XMMq=2708, + XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2709, + XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2710, + XED_IFORM_VFMSUB132SS_XMMdq_XMMd_MEMd=2711, + XED_IFORM_VFMSUB132SS_XMMdq_XMMd_XMMd=2712, + XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2713, + XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2714, + XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_MEMdq=2715, + XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_XMMdq=2716, + XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2717, + XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2718, + XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2719, + XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2720, + XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_MEMqq=2721, + XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_YMMqq=2722, + XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2723, + XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2724, + XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_MEMdq=2725, + XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_XMMdq=2726, + XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2727, + XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2728, + XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2729, + XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2730, + XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_MEMqq=2731, + XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_YMMqq=2732, + XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2733, + XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2734, + XED_IFORM_VFMSUB213SD_XMMdq_XMMq_MEMq=2735, + XED_IFORM_VFMSUB213SD_XMMdq_XMMq_XMMq=2736, + XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2737, + XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2738, + XED_IFORM_VFMSUB213SS_XMMdq_XMMd_MEMd=2739, + XED_IFORM_VFMSUB213SS_XMMdq_XMMd_XMMd=2740, + XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2741, + XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2742, + XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_MEMdq=2743, + XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_XMMdq=2744, + XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2745, + XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2746, + XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2747, + XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2748, + XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_MEMqq=2749, + XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_YMMqq=2750, + XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2751, + XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2752, + XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_MEMdq=2753, + XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_XMMdq=2754, + XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2755, + XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2756, + XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2757, + XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2758, + XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_MEMqq=2759, + XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_YMMqq=2760, + XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2761, + XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2762, + XED_IFORM_VFMSUB231SD_XMMdq_XMMq_MEMq=2763, + XED_IFORM_VFMSUB231SD_XMMdq_XMMq_XMMq=2764, + XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2765, + XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2766, + XED_IFORM_VFMSUB231SS_XMMdq_XMMd_MEMd=2767, + XED_IFORM_VFMSUB231SS_XMMdq_XMMd_XMMd=2768, + XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2769, + XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2770, + XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_MEMdq=2771, + XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_XMMdq=2772, + XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2773, + XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2774, + XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2775, + XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2776, + XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_MEMqq=2777, + XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_YMMqq=2778, + XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2779, + XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2780, + XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_MEMdq=2781, + XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_XMMdq=2782, + XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2783, + XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2784, + XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2785, + XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2786, + XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_MEMqq=2787, + XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_YMMqq=2788, + XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2789, + XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2790, + XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_MEMdq=2791, + XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_XMMdq=2792, + XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2793, + XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2794, + XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2795, + XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2796, + XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_MEMqq=2797, + XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_YMMqq=2798, + XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2799, + XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2800, + XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_MEMdq=2801, + XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_XMMdq=2802, + XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2803, + XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2804, + XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2805, + XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2806, + XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_MEMqq=2807, + XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_YMMqq=2808, + XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2809, + XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2810, + XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_MEMdq=2811, + XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_XMMdq=2812, + XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2813, + XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2814, + XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2815, + XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2816, + XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_MEMqq=2817, + XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_YMMqq=2818, + XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2819, + XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2820, + XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_MEMdq=2821, + XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_XMMdq=2822, + XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2823, + XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2824, + XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2825, + XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2826, + XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_MEMqq=2827, + XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_YMMqq=2828, + XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2829, + XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2830, + XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_MEMdq_XMMdq=2831, + XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_MEMdq=2832, + XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_XMMdq=2833, + XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_MEMqq_YMMqq=2834, + XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_MEMqq=2835, + XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_YMMqq=2836, + XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_MEMdq_XMMdq=2837, + XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_MEMdq=2838, + XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_XMMdq=2839, + XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_MEMqq_YMMqq=2840, + XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_MEMqq=2841, + XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_YMMqq=2842, + XED_IFORM_VFMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=2843, + XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=2844, + XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=2845, + XED_IFORM_VFMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=2846, + XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=2847, + XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=2848, + XED_IFORM_VFMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=2849, + XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=2850, + XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=2851, + XED_IFORM_VFMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=2852, + XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=2853, + XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=2854, + XED_IFORM_VFMSUBSD_XMMdq_XMMdq_MEMq_XMMdq=2855, + XED_IFORM_VFMSUBSD_XMMdq_XMMdq_XMMdq_MEMq=2856, + XED_IFORM_VFMSUBSD_XMMdq_XMMdq_XMMdq_XMMq=2857, + XED_IFORM_VFMSUBSD_XMMdq_XMMdq_XMMq_XMMdq=2858, + XED_IFORM_VFMSUBSS_XMMdq_XMMdq_MEMd_XMMdq=2859, + XED_IFORM_VFMSUBSS_XMMdq_XMMdq_XMMd_XMMdq=2860, + XED_IFORM_VFMSUBSS_XMMdq_XMMdq_XMMdq_MEMd=2861, + XED_IFORM_VFMSUBSS_XMMdq_XMMdq_XMMdq_XMMd=2862, + XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_MEMdq=2863, + XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_XMMdq=2864, + XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2865, + XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2866, + XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2867, + XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2868, + XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_MEMqq=2869, + XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_YMMqq=2870, + XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2871, + XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2872, + XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_MEMdq=2873, + XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_XMMdq=2874, + XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2875, + XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2876, + XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2877, + XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2878, + XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_MEMqq=2879, + XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_YMMqq=2880, + XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2881, + XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2882, + XED_IFORM_VFNMADD132SD_XMMdq_XMMq_MEMq=2883, + XED_IFORM_VFNMADD132SD_XMMdq_XMMq_XMMq=2884, + XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2885, + XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2886, + XED_IFORM_VFNMADD132SS_XMMdq_XMMd_MEMd=2887, + XED_IFORM_VFNMADD132SS_XMMdq_XMMd_XMMd=2888, + XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2889, + XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2890, + XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_MEMdq=2891, + XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_XMMdq=2892, + XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2893, + XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2894, + XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2895, + XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2896, + XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_MEMqq=2897, + XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_YMMqq=2898, + XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2899, + XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2900, + XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_MEMdq=2901, + XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_XMMdq=2902, + XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2903, + XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2904, + XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2905, + XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2906, + XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_MEMqq=2907, + XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_YMMqq=2908, + XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2909, + XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2910, + XED_IFORM_VFNMADD213SD_XMMdq_XMMq_MEMq=2911, + XED_IFORM_VFNMADD213SD_XMMdq_XMMq_XMMq=2912, + XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2913, + XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2914, + XED_IFORM_VFNMADD213SS_XMMdq_XMMd_MEMd=2915, + XED_IFORM_VFNMADD213SS_XMMdq_XMMd_XMMd=2916, + XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2917, + XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2918, + XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_MEMdq=2919, + XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_XMMdq=2920, + XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2921, + XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2922, + XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2923, + XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2924, + XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_MEMqq=2925, + XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_YMMqq=2926, + XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2927, + XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2928, + XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_MEMdq=2929, + XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_XMMdq=2930, + XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2931, + XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2932, + XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2933, + XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2934, + XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_MEMqq=2935, + XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_YMMqq=2936, + XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2937, + XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2938, + XED_IFORM_VFNMADD231SD_XMMdq_XMMq_MEMq=2939, + XED_IFORM_VFNMADD231SD_XMMdq_XMMq_XMMq=2940, + XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2941, + XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2942, + XED_IFORM_VFNMADD231SS_XMMdq_XMMd_MEMd=2943, + XED_IFORM_VFNMADD231SS_XMMdq_XMMd_XMMd=2944, + XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2945, + XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2946, + XED_IFORM_VFNMADDPD_XMMdq_XMMdq_MEMdq_XMMdq=2947, + XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_MEMdq=2948, + XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_XMMdq=2949, + XED_IFORM_VFNMADDPD_YMMqq_YMMqq_MEMqq_YMMqq=2950, + XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_MEMqq=2951, + XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_YMMqq=2952, + XED_IFORM_VFNMADDPS_XMMdq_XMMdq_MEMdq_XMMdq=2953, + XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_MEMdq=2954, + XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_XMMdq=2955, + XED_IFORM_VFNMADDPS_YMMqq_YMMqq_MEMqq_YMMqq=2956, + XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_MEMqq=2957, + XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_YMMqq=2958, + XED_IFORM_VFNMADDSD_XMMdq_XMMdq_MEMq_XMMdq=2959, + XED_IFORM_VFNMADDSD_XMMdq_XMMdq_XMMdq_MEMq=2960, + XED_IFORM_VFNMADDSD_XMMdq_XMMdq_XMMdq_XMMq=2961, + XED_IFORM_VFNMADDSD_XMMdq_XMMdq_XMMq_XMMdq=2962, + XED_IFORM_VFNMADDSS_XMMdq_XMMdq_MEMd_XMMdq=2963, + XED_IFORM_VFNMADDSS_XMMdq_XMMdq_XMMd_XMMdq=2964, + XED_IFORM_VFNMADDSS_XMMdq_XMMdq_XMMdq_MEMd=2965, + XED_IFORM_VFNMADDSS_XMMdq_XMMdq_XMMdq_XMMd=2966, + XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_MEMdq=2967, + XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_XMMdq=2968, + XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2969, + XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2970, + XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2971, + XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2972, + XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_MEMqq=2973, + XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_YMMqq=2974, + XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2975, + XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2976, + XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_MEMdq=2977, + XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_XMMdq=2978, + XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2979, + XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2980, + XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2981, + XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2982, + XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_MEMqq=2983, + XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_YMMqq=2984, + XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2985, + XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2986, + XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_MEMq=2987, + XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_XMMq=2988, + XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2989, + XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2990, + XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_MEMd=2991, + XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_XMMd=2992, + XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2993, + XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2994, + XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_MEMdq=2995, + XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_XMMdq=2996, + XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2997, + XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2998, + XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2999, + XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3000, + XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_MEMqq=3001, + XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_YMMqq=3002, + XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3003, + XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3004, + XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_MEMdq=3005, + XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_XMMdq=3006, + XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3007, + XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3008, + XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3009, + XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3010, + XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_MEMqq=3011, + XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_YMMqq=3012, + XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3013, + XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3014, + XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_MEMq=3015, + XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_XMMq=3016, + XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3017, + XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3018, + XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_MEMd=3019, + XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_XMMd=3020, + XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3021, + XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3022, + XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_MEMdq=3023, + XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_XMMdq=3024, + XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3025, + XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3026, + XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3027, + XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3028, + XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_MEMqq=3029, + XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_YMMqq=3030, + XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3031, + XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3032, + XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_MEMdq=3033, + XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_XMMdq=3034, + XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3035, + XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3036, + XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3037, + XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3038, + XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_MEMqq=3039, + XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_YMMqq=3040, + XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3041, + XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3042, + XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_MEMq=3043, + XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_XMMq=3044, + XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3045, + XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3046, + XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_MEMd=3047, + XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_XMMd=3048, + XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3049, + XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3050, + XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=3051, + XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=3052, + XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=3053, + XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=3054, + XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=3055, + XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=3056, + XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=3057, + XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=3058, + XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=3059, + XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=3060, + XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=3061, + XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=3062, + XED_IFORM_VFNMSUBSD_XMMdq_XMMdq_MEMq_XMMdq=3063, + XED_IFORM_VFNMSUBSD_XMMdq_XMMdq_XMMdq_MEMq=3064, + XED_IFORM_VFNMSUBSD_XMMdq_XMMdq_XMMdq_XMMq=3065, + XED_IFORM_VFNMSUBSD_XMMdq_XMMdq_XMMq_XMMdq=3066, + XED_IFORM_VFNMSUBSS_XMMdq_XMMdq_MEMd_XMMdq=3067, + XED_IFORM_VFNMSUBSS_XMMdq_XMMdq_XMMd_XMMdq=3068, + XED_IFORM_VFNMSUBSS_XMMdq_XMMdq_XMMdq_MEMd=3069, + XED_IFORM_VFNMSUBSS_XMMdq_XMMdq_XMMdq_XMMd=3070, + XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512=3071, + XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512=3072, + XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_YMMf64_IMM8_AVX512=3073, + XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_ZMMf64_IMM8_AVX512=3074, + XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512=3075, + XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512=3076, + XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_YMMf32_IMM8_AVX512=3077, + XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_ZMMf32_IMM8_AVX512=3078, + XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512=3079, + XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512=3080, + XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512=3081, + XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512=3082, + XED_IFORM_VFRCZPD_XMMdq_MEMdq=3083, + XED_IFORM_VFRCZPD_XMMdq_XMMdq=3084, + XED_IFORM_VFRCZPD_YMMqq_MEMqq=3085, + XED_IFORM_VFRCZPD_YMMqq_YMMqq=3086, + XED_IFORM_VFRCZPS_XMMdq_MEMdq=3087, + XED_IFORM_VFRCZPS_XMMdq_XMMdq=3088, + XED_IFORM_VFRCZPS_YMMqq_MEMqq=3089, + XED_IFORM_VFRCZPS_YMMqq_YMMqq=3090, + XED_IFORM_VFRCZSD_XMMdq_MEMq=3091, + XED_IFORM_VFRCZSD_XMMdq_XMMq=3092, + XED_IFORM_VFRCZSS_XMMdq_MEMd=3093, + XED_IFORM_VFRCZSS_XMMdq_XMMd=3094, + XED_IFORM_VGATHERDPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128=3095, + XED_IFORM_VGATHERDPD_XMMf64_MEMdq_XMMi64_VL128=3096, + XED_IFORM_VGATHERDPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256=3097, + XED_IFORM_VGATHERDPD_YMMf64_MEMqq_YMMi64_VL256=3098, + XED_IFORM_VGATHERDPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512=3099, + XED_IFORM_VGATHERDPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128=3100, + XED_IFORM_VGATHERDPS_XMMf32_MEMdq_XMMi32_VL128=3101, + XED_IFORM_VGATHERDPS_YMMf32_MASKmskw_MEMf32_AVX512_VL256=3102, + XED_IFORM_VGATHERDPS_YMMf32_MEMqq_YMMi32_VL256=3103, + XED_IFORM_VGATHERDPS_ZMMf32_MASKmskw_MEMf32_AVX512_VL512=3104, + XED_IFORM_VGATHERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512=3105, + XED_IFORM_VGATHERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512=3106, + XED_IFORM_VGATHERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512=3107, + XED_IFORM_VGATHERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512=3108, + XED_IFORM_VGATHERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512=3109, + XED_IFORM_VGATHERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512=3110, + XED_IFORM_VGATHERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512=3111, + XED_IFORM_VGATHERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512=3112, + XED_IFORM_VGATHERQPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128=3113, + XED_IFORM_VGATHERQPD_XMMf64_MEMdq_XMMi64_VL128=3114, + XED_IFORM_VGATHERQPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256=3115, + XED_IFORM_VGATHERQPD_YMMf64_MEMqq_YMMi64_VL256=3116, + XED_IFORM_VGATHERQPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512=3117, + XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128=3118, + XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL256=3119, + XED_IFORM_VGATHERQPS_XMMf32_MEMdq_XMMi32_VL256=3120, + XED_IFORM_VGATHERQPS_XMMf32_MEMq_XMMi32_VL128=3121, + XED_IFORM_VGATHERQPS_YMMf32_MASKmskw_MEMf32_AVX512_VL512=3122, + XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_MEMf64_AVX512=3123, + XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_XMMf64_AVX512=3124, + XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_MEMf64_AVX512=3125, + XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_YMMf64_AVX512=3126, + XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_MEMf64_AVX512=3127, + XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_ZMMf64_AVX512=3128, + XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_MEMf32_AVX512=3129, + XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_XMMf32_AVX512=3130, + XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_MEMf32_AVX512=3131, + XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_YMMf32_AVX512=3132, + XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_MEMf32_AVX512=3133, + XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_ZMMf32_AVX512=3134, + XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3135, + XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3136, + XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3137, + XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3138, + XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=3139, + XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=3140, + XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=3141, + XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=3142, + XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=3143, + XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=3144, + XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=3145, + XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=3146, + XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=3147, + XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=3148, + XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=3149, + XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=3150, + XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=3151, + XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=3152, + XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=3153, + XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=3154, + XED_IFORM_VHADDPD_XMMdq_XMMdq_MEMdq=3155, + XED_IFORM_VHADDPD_XMMdq_XMMdq_XMMdq=3156, + XED_IFORM_VHADDPD_YMMqq_YMMqq_MEMqq=3157, + XED_IFORM_VHADDPD_YMMqq_YMMqq_YMMqq=3158, + XED_IFORM_VHADDPS_XMMdq_XMMdq_MEMdq=3159, + XED_IFORM_VHADDPS_XMMdq_XMMdq_XMMdq=3160, + XED_IFORM_VHADDPS_YMMqq_YMMqq_MEMqq=3161, + XED_IFORM_VHADDPS_YMMqq_YMMqq_YMMqq=3162, + XED_IFORM_VHSUBPD_XMMdq_XMMdq_MEMdq=3163, + XED_IFORM_VHSUBPD_XMMdq_XMMdq_XMMdq=3164, + XED_IFORM_VHSUBPD_YMMqq_YMMqq_MEMqq=3165, + XED_IFORM_VHSUBPD_YMMqq_YMMqq_YMMqq=3166, + XED_IFORM_VHSUBPS_XMMdq_XMMdq_MEMdq=3167, + XED_IFORM_VHSUBPS_XMMdq_XMMdq_XMMdq=3168, + XED_IFORM_VHSUBPS_YMMqq_YMMqq_MEMqq=3169, + XED_IFORM_VHSUBPS_YMMqq_YMMqq_YMMqq=3170, + XED_IFORM_VINSERTF128_YMMqq_YMMqq_MEMdq_IMMb=3171, + XED_IFORM_VINSERTF128_YMMqq_YMMqq_XMMdq_IMMb=3172, + XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=3173, + XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_XMMf32_IMM8_AVX512=3174, + XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=3175, + XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_XMMf32_IMM8_AVX512=3176, + XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=3177, + XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_YMMf32_IMM8_AVX512=3178, + XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=3179, + XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_XMMf64_IMM8_AVX512=3180, + XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=3181, + XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_XMMf64_IMM8_AVX512=3182, + XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=3183, + XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_YMMf64_IMM8_AVX512=3184, + XED_IFORM_VINSERTI128_YMMqq_YMMqq_MEMdq_IMMb=3185, + XED_IFORM_VINSERTI128_YMMqq_YMMqq_XMMdq_IMMb=3186, + XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=3187, + XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_XMMu32_IMM8_AVX512=3188, + XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=3189, + XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_XMMu32_IMM8_AVX512=3190, + XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=3191, + XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_YMMu32_IMM8_AVX512=3192, + XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=3193, + XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_XMMu64_IMM8_AVX512=3194, + XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=3195, + XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_XMMu64_IMM8_AVX512=3196, + XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=3197, + XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_YMMu64_IMM8_AVX512=3198, + XED_IFORM_VINSERTPS_XMMdq_XMMdq_MEMd_IMMb=3199, + XED_IFORM_VINSERTPS_XMMdq_XMMdq_XMMdq_IMMb=3200, + XED_IFORM_VINSERTPS_XMMf32_XMMf32_MEMf32_IMM8_AVX512=3201, + XED_IFORM_VINSERTPS_XMMf32_XMMf32_XMMf32_IMM8_AVX512=3202, + XED_IFORM_VLDDQU_XMMdq_MEMdq=3203, + XED_IFORM_VLDDQU_YMMqq_MEMqq=3204, + XED_IFORM_VLDMXCSR_MEMd=3205, + XED_IFORM_VMASKMOVDQU_XMMdq_XMMdq=3206, + XED_IFORM_VMASKMOVPD_MEMdq_XMMdq_XMMdq=3207, + XED_IFORM_VMASKMOVPD_MEMqq_YMMqq_YMMqq=3208, + XED_IFORM_VMASKMOVPD_XMMdq_XMMdq_MEMdq=3209, + XED_IFORM_VMASKMOVPD_YMMqq_YMMqq_MEMqq=3210, + XED_IFORM_VMASKMOVPS_MEMdq_XMMdq_XMMdq=3211, + XED_IFORM_VMASKMOVPS_MEMqq_YMMqq_YMMqq=3212, + XED_IFORM_VMASKMOVPS_XMMdq_XMMdq_MEMdq=3213, + XED_IFORM_VMASKMOVPS_YMMqq_YMMqq_MEMqq=3214, + XED_IFORM_VMAXPD_XMMdq_XMMdq_MEMdq=3215, + XED_IFORM_VMAXPD_XMMdq_XMMdq_XMMdq=3216, + XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3217, + XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3218, + XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3219, + XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3220, + XED_IFORM_VMAXPD_YMMqq_YMMqq_MEMqq=3221, + XED_IFORM_VMAXPD_YMMqq_YMMqq_YMMqq=3222, + XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3223, + XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3224, + XED_IFORM_VMAXPS_XMMdq_XMMdq_MEMdq=3225, + XED_IFORM_VMAXPS_XMMdq_XMMdq_XMMdq=3226, + XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3227, + XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3228, + XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3229, + XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3230, + XED_IFORM_VMAXPS_YMMqq_YMMqq_MEMqq=3231, + XED_IFORM_VMAXPS_YMMqq_YMMqq_YMMqq=3232, + XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3233, + XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3234, + XED_IFORM_VMAXSD_XMMdq_XMMdq_MEMq=3235, + XED_IFORM_VMAXSD_XMMdq_XMMdq_XMMq=3236, + XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3237, + XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3238, + XED_IFORM_VMAXSS_XMMdq_XMMdq_MEMd=3239, + XED_IFORM_VMAXSS_XMMdq_XMMdq_XMMd=3240, + XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3241, + XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3242, + XED_IFORM_VMCALL=3243, + XED_IFORM_VMCLEAR_MEMq=3244, + XED_IFORM_VMFUNC=3245, + XED_IFORM_VMINPD_XMMdq_XMMdq_MEMdq=3246, + XED_IFORM_VMINPD_XMMdq_XMMdq_XMMdq=3247, + XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3248, + XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3249, + XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3250, + XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3251, + XED_IFORM_VMINPD_YMMqq_YMMqq_MEMqq=3252, + XED_IFORM_VMINPD_YMMqq_YMMqq_YMMqq=3253, + XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3254, + XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3255, + XED_IFORM_VMINPS_XMMdq_XMMdq_MEMdq=3256, + XED_IFORM_VMINPS_XMMdq_XMMdq_XMMdq=3257, + XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3258, + XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3259, + XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3260, + XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3261, + XED_IFORM_VMINPS_YMMqq_YMMqq_MEMqq=3262, + XED_IFORM_VMINPS_YMMqq_YMMqq_YMMqq=3263, + XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3264, + XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3265, + XED_IFORM_VMINSD_XMMdq_XMMdq_MEMq=3266, + XED_IFORM_VMINSD_XMMdq_XMMdq_XMMq=3267, + XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3268, + XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3269, + XED_IFORM_VMINSS_XMMdq_XMMdq_MEMd=3270, + XED_IFORM_VMINSS_XMMdq_XMMdq_XMMd=3271, + XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3272, + XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3273, + XED_IFORM_VMLAUNCH=3274, + XED_IFORM_VMLOAD_OrAX=3275, + XED_IFORM_VMMCALL=3276, + XED_IFORM_VMOVAPD_MEMdq_XMMdq=3277, + XED_IFORM_VMOVAPD_MEMf64_MASKmskw_XMMf64_AVX512=3278, + XED_IFORM_VMOVAPD_MEMf64_MASKmskw_YMMf64_AVX512=3279, + XED_IFORM_VMOVAPD_MEMf64_MASKmskw_ZMMf64_AVX512=3280, + XED_IFORM_VMOVAPD_MEMqq_YMMqq=3281, + XED_IFORM_VMOVAPD_XMMdq_MEMdq=3282, + XED_IFORM_VMOVAPD_XMMdq_XMMdq_28=3283, + XED_IFORM_VMOVAPD_XMMdq_XMMdq_29=3284, + XED_IFORM_VMOVAPD_XMMf64_MASKmskw_MEMf64_AVX512=3285, + XED_IFORM_VMOVAPD_XMMf64_MASKmskw_XMMf64_AVX512=3286, + XED_IFORM_VMOVAPD_YMMf64_MASKmskw_MEMf64_AVX512=3287, + XED_IFORM_VMOVAPD_YMMf64_MASKmskw_YMMf64_AVX512=3288, + XED_IFORM_VMOVAPD_YMMqq_MEMqq=3289, + XED_IFORM_VMOVAPD_YMMqq_YMMqq_28=3290, + XED_IFORM_VMOVAPD_YMMqq_YMMqq_29=3291, + XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_MEMf64_AVX512=3292, + XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_ZMMf64_AVX512=3293, + XED_IFORM_VMOVAPS_MEMdq_XMMdq=3294, + XED_IFORM_VMOVAPS_MEMf32_MASKmskw_XMMf32_AVX512=3295, + XED_IFORM_VMOVAPS_MEMf32_MASKmskw_YMMf32_AVX512=3296, + XED_IFORM_VMOVAPS_MEMf32_MASKmskw_ZMMf32_AVX512=3297, + XED_IFORM_VMOVAPS_MEMqq_YMMqq=3298, + XED_IFORM_VMOVAPS_XMMdq_MEMdq=3299, + XED_IFORM_VMOVAPS_XMMdq_XMMdq_28=3300, + XED_IFORM_VMOVAPS_XMMdq_XMMdq_29=3301, + XED_IFORM_VMOVAPS_XMMf32_MASKmskw_MEMf32_AVX512=3302, + XED_IFORM_VMOVAPS_XMMf32_MASKmskw_XMMf32_AVX512=3303, + XED_IFORM_VMOVAPS_YMMf32_MASKmskw_MEMf32_AVX512=3304, + XED_IFORM_VMOVAPS_YMMf32_MASKmskw_YMMf32_AVX512=3305, + XED_IFORM_VMOVAPS_YMMqq_MEMqq=3306, + XED_IFORM_VMOVAPS_YMMqq_YMMqq_28=3307, + XED_IFORM_VMOVAPS_YMMqq_YMMqq_29=3308, + XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_MEMf32_AVX512=3309, + XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_ZMMf32_AVX512=3310, + XED_IFORM_VMOVD_GPR32d_XMMd=3311, + XED_IFORM_VMOVD_GPR32u32_XMMu32_AVX512=3312, + XED_IFORM_VMOVD_MEMd_XMMd=3313, + XED_IFORM_VMOVD_MEMu32_XMMu32_AVX512=3314, + XED_IFORM_VMOVD_XMMdq_GPR32d=3315, + XED_IFORM_VMOVD_XMMdq_MEMd=3316, + XED_IFORM_VMOVD_XMMu32_GPR32u32_AVX512=3317, + XED_IFORM_VMOVD_XMMu32_MEMu32_AVX512=3318, + XED_IFORM_VMOVDDUP_XMMdq_MEMq=3319, + XED_IFORM_VMOVDDUP_XMMdq_XMMdq=3320, + XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_MEMf64_AVX512=3321, + XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_XMMf64_AVX512=3322, + XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_MEMf64_AVX512=3323, + XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_YMMf64_AVX512=3324, + XED_IFORM_VMOVDDUP_YMMqq_MEMqq=3325, + XED_IFORM_VMOVDDUP_YMMqq_YMMqq=3326, + XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_MEMf64_AVX512=3327, + XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_ZMMf64_AVX512=3328, + XED_IFORM_VMOVDQA_MEMdq_XMMdq=3329, + XED_IFORM_VMOVDQA_MEMqq_YMMqq=3330, + XED_IFORM_VMOVDQA_XMMdq_MEMdq=3331, + XED_IFORM_VMOVDQA_XMMdq_XMMdq_6F=3332, + XED_IFORM_VMOVDQA_XMMdq_XMMdq_7F=3333, + XED_IFORM_VMOVDQA_YMMqq_MEMqq=3334, + XED_IFORM_VMOVDQA_YMMqq_YMMqq_6F=3335, + XED_IFORM_VMOVDQA_YMMqq_YMMqq_7F=3336, + XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_XMMu32_AVX512=3337, + XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_YMMu32_AVX512=3338, + XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_ZMMu32_AVX512=3339, + XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_MEMu32_AVX512=3340, + XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_XMMu32_AVX512=3341, + XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_MEMu32_AVX512=3342, + XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_YMMu32_AVX512=3343, + XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_MEMu32_AVX512=3344, + XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_ZMMu32_AVX512=3345, + XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_XMMu64_AVX512=3346, + XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_YMMu64_AVX512=3347, + XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_ZMMu64_AVX512=3348, + XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_MEMu64_AVX512=3349, + XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_XMMu64_AVX512=3350, + XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_MEMu64_AVX512=3351, + XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_YMMu64_AVX512=3352, + XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_MEMu64_AVX512=3353, + XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_ZMMu64_AVX512=3354, + XED_IFORM_VMOVDQU_MEMdq_XMMdq=3355, + XED_IFORM_VMOVDQU_MEMqq_YMMqq=3356, + XED_IFORM_VMOVDQU_XMMdq_MEMdq=3357, + XED_IFORM_VMOVDQU_XMMdq_XMMdq_6F=3358, + XED_IFORM_VMOVDQU_XMMdq_XMMdq_7F=3359, + XED_IFORM_VMOVDQU_YMMqq_MEMqq=3360, + XED_IFORM_VMOVDQU_YMMqq_YMMqq_6F=3361, + XED_IFORM_VMOVDQU_YMMqq_YMMqq_7F=3362, + XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_XMMu16_AVX512=3363, + XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_YMMu16_AVX512=3364, + XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_ZMMu16_AVX512=3365, + XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_MEMu16_AVX512=3366, + XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_XMMu16_AVX512=3367, + XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_MEMu16_AVX512=3368, + XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_YMMu16_AVX512=3369, + XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_MEMu16_AVX512=3370, + XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_ZMMu16_AVX512=3371, + XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_XMMu32_AVX512=3372, + XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_YMMu32_AVX512=3373, + XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_ZMMu32_AVX512=3374, + XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_MEMu32_AVX512=3375, + XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_XMMu32_AVX512=3376, + XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_MEMu32_AVX512=3377, + XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_YMMu32_AVX512=3378, + XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_MEMu32_AVX512=3379, + XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_ZMMu32_AVX512=3380, + XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_XMMu64_AVX512=3381, + XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_YMMu64_AVX512=3382, + XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_ZMMu64_AVX512=3383, + XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_MEMu64_AVX512=3384, + XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_XMMu64_AVX512=3385, + XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_MEMu64_AVX512=3386, + XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_YMMu64_AVX512=3387, + XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_MEMu64_AVX512=3388, + XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_ZMMu64_AVX512=3389, + XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_XMMu8_AVX512=3390, + XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_YMMu8_AVX512=3391, + XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_ZMMu8_AVX512=3392, + XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_MEMu8_AVX512=3393, + XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_XMMu8_AVX512=3394, + XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_MEMu8_AVX512=3395, + XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_YMMu8_AVX512=3396, + XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_MEMu8_AVX512=3397, + XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_ZMMu8_AVX512=3398, + XED_IFORM_VMOVHLPS_XMMdq_XMMdq_XMMdq=3399, + XED_IFORM_VMOVHLPS_XMMf32_XMMf32_XMMf32_AVX512=3400, + XED_IFORM_VMOVHPD_MEMf64_XMMf64_AVX512=3401, + XED_IFORM_VMOVHPD_MEMq_XMMdq=3402, + XED_IFORM_VMOVHPD_XMMdq_XMMq_MEMq=3403, + XED_IFORM_VMOVHPD_XMMf64_XMMf64_MEMf64_AVX512=3404, + XED_IFORM_VMOVHPS_MEMf32_XMMf32_AVX512=3405, + XED_IFORM_VMOVHPS_MEMq_XMMdq=3406, + XED_IFORM_VMOVHPS_XMMdq_XMMq_MEMq=3407, + XED_IFORM_VMOVHPS_XMMf32_XMMf32_MEMf32_AVX512=3408, + XED_IFORM_VMOVLHPS_XMMdq_XMMq_XMMq=3409, + XED_IFORM_VMOVLHPS_XMMf32_XMMf32_XMMf32_AVX512=3410, + XED_IFORM_VMOVLPD_MEMf64_XMMf64_AVX512=3411, + XED_IFORM_VMOVLPD_MEMq_XMMq=3412, + XED_IFORM_VMOVLPD_XMMdq_XMMdq_MEMq=3413, + XED_IFORM_VMOVLPD_XMMf64_XMMf64_MEMf64_AVX512=3414, + XED_IFORM_VMOVLPS_MEMf32_XMMf32_AVX512=3415, + XED_IFORM_VMOVLPS_MEMq_XMMq=3416, + XED_IFORM_VMOVLPS_XMMdq_XMMdq_MEMq=3417, + XED_IFORM_VMOVLPS_XMMf32_XMMf32_MEMf32_AVX512=3418, + XED_IFORM_VMOVMSKPD_GPR32d_XMMdq=3419, + XED_IFORM_VMOVMSKPD_GPR32d_YMMqq=3420, + XED_IFORM_VMOVMSKPS_GPR32d_XMMdq=3421, + XED_IFORM_VMOVMSKPS_GPR32d_YMMqq=3422, + XED_IFORM_VMOVNTDQ_MEMdq_XMMdq=3423, + XED_IFORM_VMOVNTDQ_MEMqq_YMMqq=3424, + XED_IFORM_VMOVNTDQ_MEMu32_XMMu32_AVX512=3425, + XED_IFORM_VMOVNTDQ_MEMu32_YMMu32_AVX512=3426, + XED_IFORM_VMOVNTDQ_MEMu32_ZMMu32_AVX512=3427, + XED_IFORM_VMOVNTDQA_XMMdq_MEMdq=3428, + XED_IFORM_VMOVNTDQA_XMMu32_MEMu32_AVX512=3429, + XED_IFORM_VMOVNTDQA_YMMqq_MEMqq=3430, + XED_IFORM_VMOVNTDQA_YMMu32_MEMu32_AVX512=3431, + XED_IFORM_VMOVNTDQA_ZMMu32_MEMu32_AVX512=3432, + XED_IFORM_VMOVNTPD_MEMdq_XMMdq=3433, + XED_IFORM_VMOVNTPD_MEMf64_XMMf64_AVX512=3434, + XED_IFORM_VMOVNTPD_MEMf64_YMMf64_AVX512=3435, + XED_IFORM_VMOVNTPD_MEMf64_ZMMf64_AVX512=3436, + XED_IFORM_VMOVNTPD_MEMqq_YMMqq=3437, + XED_IFORM_VMOVNTPS_MEMdq_XMMdq=3438, + XED_IFORM_VMOVNTPS_MEMf32_XMMf32_AVX512=3439, + XED_IFORM_VMOVNTPS_MEMf32_YMMf32_AVX512=3440, + XED_IFORM_VMOVNTPS_MEMf32_ZMMf32_AVX512=3441, + XED_IFORM_VMOVNTPS_MEMqq_YMMqq=3442, + XED_IFORM_VMOVQ_GPR64q_XMMq=3443, + XED_IFORM_VMOVQ_GPR64u64_XMMu64_AVX512=3444, + XED_IFORM_VMOVQ_MEMq_XMMq_7E=3445, + XED_IFORM_VMOVQ_MEMq_XMMq_D6=3446, + XED_IFORM_VMOVQ_MEMu64_XMMu64_AVX512=3447, + XED_IFORM_VMOVQ_XMMdq_GPR64q=3448, + XED_IFORM_VMOVQ_XMMdq_MEMq_6E=3449, + XED_IFORM_VMOVQ_XMMdq_MEMq_7E=3450, + XED_IFORM_VMOVQ_XMMdq_XMMq_7E=3451, + XED_IFORM_VMOVQ_XMMdq_XMMq_D6=3452, + XED_IFORM_VMOVQ_XMMu64_GPR64u64_AVX512=3453, + XED_IFORM_VMOVQ_XMMu64_MEMu64_AVX512=3454, + XED_IFORM_VMOVQ_XMMu64_XMMu64_AVX512=3455, + XED_IFORM_VMOVSD_MEMf64_MASKmskw_XMMf64_AVX512=3456, + XED_IFORM_VMOVSD_MEMq_XMMq=3457, + XED_IFORM_VMOVSD_XMMdq_MEMq=3458, + XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_10=3459, + XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_11=3460, + XED_IFORM_VMOVSD_XMMf64_MASKmskw_MEMf64_AVX512=3461, + XED_IFORM_VMOVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3462, + XED_IFORM_VMOVSHDUP_XMMdq_MEMdq=3463, + XED_IFORM_VMOVSHDUP_XMMdq_XMMdq=3464, + XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_MEMf32_AVX512=3465, + XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_XMMf32_AVX512=3466, + XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_MEMf32_AVX512=3467, + XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_YMMf32_AVX512=3468, + XED_IFORM_VMOVSHDUP_YMMqq_MEMqq=3469, + XED_IFORM_VMOVSHDUP_YMMqq_YMMqq=3470, + XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_MEMf32_AVX512=3471, + XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_ZMMf32_AVX512=3472, + XED_IFORM_VMOVSLDUP_XMMdq_MEMdq=3473, + XED_IFORM_VMOVSLDUP_XMMdq_XMMdq=3474, + XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_MEMf32_AVX512=3475, + XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_XMMf32_AVX512=3476, + XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_MEMf32_AVX512=3477, + XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_YMMf32_AVX512=3478, + XED_IFORM_VMOVSLDUP_YMMqq_MEMqq=3479, + XED_IFORM_VMOVSLDUP_YMMqq_YMMqq=3480, + XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_MEMf32_AVX512=3481, + XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_ZMMf32_AVX512=3482, + XED_IFORM_VMOVSS_MEMd_XMMd=3483, + XED_IFORM_VMOVSS_MEMf32_MASKmskw_XMMf32_AVX512=3484, + XED_IFORM_VMOVSS_XMMdq_MEMd=3485, + XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_10=3486, + XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_11=3487, + XED_IFORM_VMOVSS_XMMf32_MASKmskw_MEMf32_AVX512=3488, + XED_IFORM_VMOVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3489, + XED_IFORM_VMOVUPD_MEMdq_XMMdq=3490, + XED_IFORM_VMOVUPD_MEMf64_MASKmskw_XMMf64_AVX512=3491, + XED_IFORM_VMOVUPD_MEMf64_MASKmskw_YMMf64_AVX512=3492, + XED_IFORM_VMOVUPD_MEMf64_MASKmskw_ZMMf64_AVX512=3493, + XED_IFORM_VMOVUPD_MEMqq_YMMqq=3494, + XED_IFORM_VMOVUPD_XMMdq_MEMdq=3495, + XED_IFORM_VMOVUPD_XMMdq_XMMdq_10=3496, + XED_IFORM_VMOVUPD_XMMdq_XMMdq_11=3497, + XED_IFORM_VMOVUPD_XMMf64_MASKmskw_MEMf64_AVX512=3498, + XED_IFORM_VMOVUPD_XMMf64_MASKmskw_XMMf64_AVX512=3499, + XED_IFORM_VMOVUPD_YMMf64_MASKmskw_MEMf64_AVX512=3500, + XED_IFORM_VMOVUPD_YMMf64_MASKmskw_YMMf64_AVX512=3501, + XED_IFORM_VMOVUPD_YMMqq_MEMqq=3502, + XED_IFORM_VMOVUPD_YMMqq_YMMqq_10=3503, + XED_IFORM_VMOVUPD_YMMqq_YMMqq_11=3504, + XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_MEMf64_AVX512=3505, + XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_ZMMf64_AVX512=3506, + XED_IFORM_VMOVUPS_MEMdq_XMMdq=3507, + XED_IFORM_VMOVUPS_MEMf32_MASKmskw_XMMf32_AVX512=3508, + XED_IFORM_VMOVUPS_MEMf32_MASKmskw_YMMf32_AVX512=3509, + XED_IFORM_VMOVUPS_MEMf32_MASKmskw_ZMMf32_AVX512=3510, + XED_IFORM_VMOVUPS_MEMqq_YMMqq=3511, + XED_IFORM_VMOVUPS_XMMdq_MEMdq=3512, + XED_IFORM_VMOVUPS_XMMdq_XMMdq_10=3513, + XED_IFORM_VMOVUPS_XMMdq_XMMdq_11=3514, + XED_IFORM_VMOVUPS_XMMf32_MASKmskw_MEMf32_AVX512=3515, + XED_IFORM_VMOVUPS_XMMf32_MASKmskw_XMMf32_AVX512=3516, + XED_IFORM_VMOVUPS_YMMf32_MASKmskw_MEMf32_AVX512=3517, + XED_IFORM_VMOVUPS_YMMf32_MASKmskw_YMMf32_AVX512=3518, + XED_IFORM_VMOVUPS_YMMqq_MEMqq=3519, + XED_IFORM_VMOVUPS_YMMqq_YMMqq_10=3520, + XED_IFORM_VMOVUPS_YMMqq_YMMqq_11=3521, + XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_MEMf32_AVX512=3522, + XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_ZMMf32_AVX512=3523, + XED_IFORM_VMPSADBW_XMMdq_XMMdq_MEMdq_IMMb=3524, + XED_IFORM_VMPSADBW_XMMdq_XMMdq_XMMdq_IMMb=3525, + XED_IFORM_VMPSADBW_YMMqq_YMMqq_MEMqq_IMMb=3526, + XED_IFORM_VMPSADBW_YMMqq_YMMqq_YMMqq_IMMb=3527, + XED_IFORM_VMPTRLD_MEMq=3528, + XED_IFORM_VMPTRST_MEMq=3529, + XED_IFORM_VMREAD_GPR32_GPR32=3530, + XED_IFORM_VMREAD_GPR64_GPR64=3531, + XED_IFORM_VMREAD_MEMd_GPR32=3532, + XED_IFORM_VMREAD_MEMq_GPR64=3533, + XED_IFORM_VMRESUME=3534, + XED_IFORM_VMRUN_OrAX=3535, + XED_IFORM_VMSAVE=3536, + XED_IFORM_VMULPD_XMMdq_XMMdq_MEMdq=3537, + XED_IFORM_VMULPD_XMMdq_XMMdq_XMMdq=3538, + XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3539, + XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3540, + XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3541, + XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3542, + XED_IFORM_VMULPD_YMMqq_YMMqq_MEMqq=3543, + XED_IFORM_VMULPD_YMMqq_YMMqq_YMMqq=3544, + XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3545, + XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3546, + XED_IFORM_VMULPS_XMMdq_XMMdq_MEMdq=3547, + XED_IFORM_VMULPS_XMMdq_XMMdq_XMMdq=3548, + XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3549, + XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3550, + XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3551, + XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3552, + XED_IFORM_VMULPS_YMMqq_YMMqq_MEMqq=3553, + XED_IFORM_VMULPS_YMMqq_YMMqq_YMMqq=3554, + XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3555, + XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3556, + XED_IFORM_VMULSD_XMMdq_XMMdq_MEMq=3557, + XED_IFORM_VMULSD_XMMdq_XMMdq_XMMq=3558, + XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3559, + XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3560, + XED_IFORM_VMULSS_XMMdq_XMMdq_MEMd=3561, + XED_IFORM_VMULSS_XMMdq_XMMdq_XMMd=3562, + XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3563, + XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3564, + XED_IFORM_VMWRITE_GPR32_GPR32=3565, + XED_IFORM_VMWRITE_GPR32_MEMd=3566, + XED_IFORM_VMWRITE_GPR64_GPR64=3567, + XED_IFORM_VMWRITE_GPR64_MEMq=3568, + XED_IFORM_VMXOFF=3569, + XED_IFORM_VMXON_MEMq=3570, + XED_IFORM_VORPD_XMMdq_XMMdq_MEMdq=3571, + XED_IFORM_VORPD_XMMdq_XMMdq_XMMdq=3572, + XED_IFORM_VORPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3573, + XED_IFORM_VORPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3574, + XED_IFORM_VORPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3575, + XED_IFORM_VORPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3576, + XED_IFORM_VORPD_YMMqq_YMMqq_MEMqq=3577, + XED_IFORM_VORPD_YMMqq_YMMqq_YMMqq=3578, + XED_IFORM_VORPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3579, + XED_IFORM_VORPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3580, + XED_IFORM_VORPS_XMMdq_XMMdq_MEMdq=3581, + XED_IFORM_VORPS_XMMdq_XMMdq_XMMdq=3582, + XED_IFORM_VORPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3583, + XED_IFORM_VORPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3584, + XED_IFORM_VORPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3585, + XED_IFORM_VORPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3586, + XED_IFORM_VORPS_YMMqq_YMMqq_MEMqq=3587, + XED_IFORM_VORPS_YMMqq_YMMqq_YMMqq=3588, + XED_IFORM_VORPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3589, + XED_IFORM_VORPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3590, + XED_IFORM_VPABSB_XMMdq_MEMdq=3591, + XED_IFORM_VPABSB_XMMdq_XMMdq=3592, + XED_IFORM_VPABSB_XMMi8_MASKmskw_MEMi8_AVX512=3593, + XED_IFORM_VPABSB_XMMi8_MASKmskw_XMMi8_AVX512=3594, + XED_IFORM_VPABSB_YMMi8_MASKmskw_MEMi8_AVX512=3595, + XED_IFORM_VPABSB_YMMi8_MASKmskw_YMMi8_AVX512=3596, + XED_IFORM_VPABSB_YMMqq_MEMqq=3597, + XED_IFORM_VPABSB_YMMqq_YMMqq=3598, + XED_IFORM_VPABSB_ZMMi8_MASKmskw_MEMi8_AVX512=3599, + XED_IFORM_VPABSB_ZMMi8_MASKmskw_ZMMi8_AVX512=3600, + XED_IFORM_VPABSD_XMMdq_MEMdq=3601, + XED_IFORM_VPABSD_XMMdq_XMMdq=3602, + XED_IFORM_VPABSD_XMMi32_MASKmskw_MEMi32_AVX512=3603, + XED_IFORM_VPABSD_XMMi32_MASKmskw_XMMi32_AVX512=3604, + XED_IFORM_VPABSD_YMMi32_MASKmskw_MEMi32_AVX512=3605, + XED_IFORM_VPABSD_YMMi32_MASKmskw_YMMi32_AVX512=3606, + XED_IFORM_VPABSD_YMMqq_MEMqq=3607, + XED_IFORM_VPABSD_YMMqq_YMMqq=3608, + XED_IFORM_VPABSD_ZMMi32_MASKmskw_MEMi32_AVX512=3609, + XED_IFORM_VPABSD_ZMMi32_MASKmskw_ZMMi32_AVX512=3610, + XED_IFORM_VPABSQ_XMMi64_MASKmskw_MEMi64_AVX512=3611, + XED_IFORM_VPABSQ_XMMi64_MASKmskw_XMMi64_AVX512=3612, + XED_IFORM_VPABSQ_YMMi64_MASKmskw_MEMi64_AVX512=3613, + XED_IFORM_VPABSQ_YMMi64_MASKmskw_YMMi64_AVX512=3614, + XED_IFORM_VPABSQ_ZMMi64_MASKmskw_MEMi64_AVX512=3615, + XED_IFORM_VPABSQ_ZMMi64_MASKmskw_ZMMi64_AVX512=3616, + XED_IFORM_VPABSW_XMMdq_MEMdq=3617, + XED_IFORM_VPABSW_XMMdq_XMMdq=3618, + XED_IFORM_VPABSW_XMMi16_MASKmskw_MEMi16_AVX512=3619, + XED_IFORM_VPABSW_XMMi16_MASKmskw_XMMi16_AVX512=3620, + XED_IFORM_VPABSW_YMMi16_MASKmskw_MEMi16_AVX512=3621, + XED_IFORM_VPABSW_YMMi16_MASKmskw_YMMi16_AVX512=3622, + XED_IFORM_VPABSW_YMMqq_MEMqq=3623, + XED_IFORM_VPABSW_YMMqq_YMMqq=3624, + XED_IFORM_VPABSW_ZMMi16_MASKmskw_MEMi16_AVX512=3625, + XED_IFORM_VPABSW_ZMMi16_MASKmskw_ZMMi16_AVX512=3626, + XED_IFORM_VPACKSSDW_XMMdq_XMMdq_MEMdq=3627, + XED_IFORM_VPACKSSDW_XMMdq_XMMdq_XMMdq=3628, + XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_MEMi32_AVX512=3629, + XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_XMMi32_AVX512=3630, + XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_MEMi32_AVX512=3631, + XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_YMMi32_AVX512=3632, + XED_IFORM_VPACKSSDW_YMMqq_YMMqq_MEMqq=3633, + XED_IFORM_VPACKSSDW_YMMqq_YMMqq_YMMqq=3634, + XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_MEMi32_AVX512=3635, + XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_ZMMi32_AVX512=3636, + XED_IFORM_VPACKSSWB_XMMdq_XMMdq_MEMdq=3637, + XED_IFORM_VPACKSSWB_XMMdq_XMMdq_XMMdq=3638, + XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_MEMi16_AVX512=3639, + XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_XMMi16_AVX512=3640, + XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_MEMi16_AVX512=3641, + XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_YMMi16_AVX512=3642, + XED_IFORM_VPACKSSWB_YMMqq_YMMqq_MEMqq=3643, + XED_IFORM_VPACKSSWB_YMMqq_YMMqq_YMMqq=3644, + XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_MEMi16_AVX512=3645, + XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_ZMMi16_AVX512=3646, + XED_IFORM_VPACKUSDW_XMMdq_XMMdq_MEMdq=3647, + XED_IFORM_VPACKUSDW_XMMdq_XMMdq_XMMdq=3648, + XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_MEMu32_AVX512=3649, + XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_XMMu32_AVX512=3650, + XED_IFORM_VPACKUSDW_YMMqq_YMMqq_MEMqq=3651, + XED_IFORM_VPACKUSDW_YMMqq_YMMqq_YMMqq=3652, + XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_MEMu32_AVX512=3653, + XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_YMMu32_AVX512=3654, + XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_MEMu32_AVX512=3655, + XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_ZMMu32_AVX512=3656, + XED_IFORM_VPACKUSWB_XMMdq_XMMdq_MEMdq=3657, + XED_IFORM_VPACKUSWB_XMMdq_XMMdq_XMMdq=3658, + XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_MEMu16_AVX512=3659, + XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_XMMu16_AVX512=3660, + XED_IFORM_VPACKUSWB_YMMqq_YMMqq_MEMqq=3661, + XED_IFORM_VPACKUSWB_YMMqq_YMMqq_YMMqq=3662, + XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_MEMu16_AVX512=3663, + XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_YMMu16_AVX512=3664, + XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_MEMu16_AVX512=3665, + XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_ZMMu16_AVX512=3666, + XED_IFORM_VPADDB_XMMdq_XMMdq_MEMdq=3667, + XED_IFORM_VPADDB_XMMdq_XMMdq_XMMdq=3668, + XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=3669, + XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=3670, + XED_IFORM_VPADDB_YMMqq_YMMqq_MEMqq=3671, + XED_IFORM_VPADDB_YMMqq_YMMqq_YMMqq=3672, + XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=3673, + XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=3674, + XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=3675, + XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=3676, + XED_IFORM_VPADDD_XMMdq_XMMdq_MEMdq=3677, + XED_IFORM_VPADDD_XMMdq_XMMdq_XMMdq=3678, + XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=3679, + XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=3680, + XED_IFORM_VPADDD_YMMqq_YMMqq_MEMqq=3681, + XED_IFORM_VPADDD_YMMqq_YMMqq_YMMqq=3682, + XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=3683, + XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=3684, + XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=3685, + XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=3686, + XED_IFORM_VPADDQ_XMMdq_XMMdq_MEMdq=3687, + XED_IFORM_VPADDQ_XMMdq_XMMdq_XMMdq=3688, + XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=3689, + XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=3690, + XED_IFORM_VPADDQ_YMMqq_YMMqq_MEMqq=3691, + XED_IFORM_VPADDQ_YMMqq_YMMqq_YMMqq=3692, + XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=3693, + XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=3694, + XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=3695, + XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=3696, + XED_IFORM_VPADDSB_XMMdq_XMMdq_MEMdq=3697, + XED_IFORM_VPADDSB_XMMdq_XMMdq_XMMdq=3698, + XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=3699, + XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=3700, + XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=3701, + XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=3702, + XED_IFORM_VPADDSB_YMMqq_YMMqq_MEMqq=3703, + XED_IFORM_VPADDSB_YMMqq_YMMqq_YMMqq=3704, + XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=3705, + XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=3706, + XED_IFORM_VPADDSW_XMMdq_XMMdq_MEMdq=3707, + XED_IFORM_VPADDSW_XMMdq_XMMdq_XMMdq=3708, + XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=3709, + XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=3710, + XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=3711, + XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=3712, + XED_IFORM_VPADDSW_YMMqq_YMMqq_MEMqq=3713, + XED_IFORM_VPADDSW_YMMqq_YMMqq_YMMqq=3714, + XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=3715, + XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=3716, + XED_IFORM_VPADDUSB_XMMdq_XMMdq_MEMdq=3717, + XED_IFORM_VPADDUSB_XMMdq_XMMdq_XMMdq=3718, + XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=3719, + XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=3720, + XED_IFORM_VPADDUSB_YMMqq_YMMqq_MEMqq=3721, + XED_IFORM_VPADDUSB_YMMqq_YMMqq_YMMqq=3722, + XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=3723, + XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=3724, + XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=3725, + XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=3726, + XED_IFORM_VPADDUSW_XMMdq_XMMdq_MEMdq=3727, + XED_IFORM_VPADDUSW_XMMdq_XMMdq_XMMdq=3728, + XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=3729, + XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=3730, + XED_IFORM_VPADDUSW_YMMqq_YMMqq_MEMqq=3731, + XED_IFORM_VPADDUSW_YMMqq_YMMqq_YMMqq=3732, + XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=3733, + XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=3734, + XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=3735, + XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=3736, + XED_IFORM_VPADDW_XMMdq_XMMdq_MEMdq=3737, + XED_IFORM_VPADDW_XMMdq_XMMdq_XMMdq=3738, + XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=3739, + XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=3740, + XED_IFORM_VPADDW_YMMqq_YMMqq_MEMqq=3741, + XED_IFORM_VPADDW_YMMqq_YMMqq_YMMqq=3742, + XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=3743, + XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=3744, + XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=3745, + XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=3746, + XED_IFORM_VPALIGNR_XMMdq_XMMdq_MEMdq_IMMb=3747, + XED_IFORM_VPALIGNR_XMMdq_XMMdq_XMMdq_IMMb=3748, + XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=3749, + XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=3750, + XED_IFORM_VPALIGNR_YMMqq_YMMqq_MEMqq_IMMb=3751, + XED_IFORM_VPALIGNR_YMMqq_YMMqq_YMMqq_IMMb=3752, + XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=3753, + XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=3754, + XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=3755, + XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=3756, + XED_IFORM_VPAND_XMMdq_XMMdq_MEMdq=3757, + XED_IFORM_VPAND_XMMdq_XMMdq_XMMdq=3758, + XED_IFORM_VPAND_YMMqq_YMMqq_MEMqq=3759, + XED_IFORM_VPAND_YMMqq_YMMqq_YMMqq=3760, + XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=3761, + XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=3762, + XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=3763, + XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=3764, + XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=3765, + XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=3766, + XED_IFORM_VPANDN_XMMdq_XMMdq_MEMdq=3767, + XED_IFORM_VPANDN_XMMdq_XMMdq_XMMdq=3768, + XED_IFORM_VPANDN_YMMqq_YMMqq_MEMqq=3769, + XED_IFORM_VPANDN_YMMqq_YMMqq_YMMqq=3770, + XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=3771, + XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=3772, + XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=3773, + XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=3774, + XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=3775, + XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=3776, + XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=3777, + XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=3778, + XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=3779, + XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=3780, + XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=3781, + XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=3782, + XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=3783, + XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=3784, + XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=3785, + XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=3786, + XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=3787, + XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=3788, + XED_IFORM_VPAVGB_XMMdq_XMMdq_MEMdq=3789, + XED_IFORM_VPAVGB_XMMdq_XMMdq_XMMdq=3790, + XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=3791, + XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=3792, + XED_IFORM_VPAVGB_YMMqq_YMMqq_MEMqq=3793, + XED_IFORM_VPAVGB_YMMqq_YMMqq_YMMqq=3794, + XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=3795, + XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=3796, + XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=3797, + XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=3798, + XED_IFORM_VPAVGW_XMMdq_XMMdq_MEMdq=3799, + XED_IFORM_VPAVGW_XMMdq_XMMdq_XMMdq=3800, + XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=3801, + XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=3802, + XED_IFORM_VPAVGW_YMMqq_YMMqq_MEMqq=3803, + XED_IFORM_VPAVGW_YMMqq_YMMqq_YMMqq=3804, + XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=3805, + XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=3806, + XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=3807, + XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=3808, + XED_IFORM_VPBLENDD_XMMdq_XMMdq_MEMdq_IMMb=3809, + XED_IFORM_VPBLENDD_XMMdq_XMMdq_XMMdq_IMMb=3810, + XED_IFORM_VPBLENDD_YMMqq_YMMqq_MEMqq_IMMb=3811, + XED_IFORM_VPBLENDD_YMMqq_YMMqq_YMMqq_IMMb=3812, + XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=3813, + XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=3814, + XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=3815, + XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=3816, + XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=3817, + XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=3818, + XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=3819, + XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=3820, + XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=3821, + XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=3822, + XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=3823, + XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=3824, + XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=3825, + XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=3826, + XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=3827, + XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=3828, + XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=3829, + XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=3830, + XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=3831, + XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=3832, + XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=3833, + XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=3834, + XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=3835, + XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=3836, + XED_IFORM_VPBLENDVB_XMMdq_XMMdq_MEMdq_XMMdq=3837, + XED_IFORM_VPBLENDVB_XMMdq_XMMdq_XMMdq_XMMdq=3838, + XED_IFORM_VPBLENDVB_YMMqq_YMMqq_MEMqq_YMMqq=3839, + XED_IFORM_VPBLENDVB_YMMqq_YMMqq_YMMqq_YMMqq=3840, + XED_IFORM_VPBLENDW_XMMdq_XMMdq_MEMdq_IMMb=3841, + XED_IFORM_VPBLENDW_XMMdq_XMMdq_XMMdq_IMMb=3842, + XED_IFORM_VPBLENDW_YMMqq_YMMqq_MEMqq_IMMb=3843, + XED_IFORM_VPBLENDW_YMMqq_YMMqq_YMMqq_IMMb=3844, + XED_IFORM_VPBROADCASTB_XMMdq_MEMb=3845, + XED_IFORM_VPBROADCASTB_XMMdq_XMMb=3846, + XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_GPR32u8_AVX512=3847, + XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_MEMu8_AVX512=3848, + XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_XMMu8_AVX512=3849, + XED_IFORM_VPBROADCASTB_YMMqq_MEMb=3850, + XED_IFORM_VPBROADCASTB_YMMqq_XMMb=3851, + XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_GPR32u8_AVX512=3852, + XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_MEMu8_AVX512=3853, + XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_XMMu8_AVX512=3854, + XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_GPR32u8_AVX512=3855, + XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_MEMu8_AVX512=3856, + XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_XMMu8_AVX512=3857, + XED_IFORM_VPBROADCASTD_XMMdq_MEMd=3858, + XED_IFORM_VPBROADCASTD_XMMdq_XMMd=3859, + XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_GPR32u32_AVX512=3860, + XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_MEMu32_AVX512=3861, + XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_XMMu32_AVX512=3862, + XED_IFORM_VPBROADCASTD_YMMqq_MEMd=3863, + XED_IFORM_VPBROADCASTD_YMMqq_XMMd=3864, + XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_GPR32u32_AVX512=3865, + XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_MEMu32_AVX512=3866, + XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_XMMu32_AVX512=3867, + XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_GPR32u32_AVX512=3868, + XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_MEMu32_AVX512=3869, + XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_XMMu32_AVX512=3870, + XED_IFORM_VPBROADCASTMB2Q_XMMu64_MASKu64_AVX512=3871, + XED_IFORM_VPBROADCASTMB2Q_YMMu64_MASKu64_AVX512=3872, + XED_IFORM_VPBROADCASTMB2Q_ZMMu64_MASKu64_AVX512CD=3873, + XED_IFORM_VPBROADCASTMW2D_XMMu32_MASKu32_AVX512=3874, + XED_IFORM_VPBROADCASTMW2D_YMMu32_MASKu32_AVX512=3875, + XED_IFORM_VPBROADCASTMW2D_ZMMu32_MASKu32_AVX512CD=3876, + XED_IFORM_VPBROADCASTQ_XMMdq_MEMq=3877, + XED_IFORM_VPBROADCASTQ_XMMdq_XMMq=3878, + XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_GPR64u64_AVX512=3879, + XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_MEMu64_AVX512=3880, + XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_XMMu64_AVX512=3881, + XED_IFORM_VPBROADCASTQ_YMMqq_MEMq=3882, + XED_IFORM_VPBROADCASTQ_YMMqq_XMMq=3883, + XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_GPR64u64_AVX512=3884, + XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_MEMu64_AVX512=3885, + XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_XMMu64_AVX512=3886, + XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_GPR64u64_AVX512=3887, + XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_MEMu64_AVX512=3888, + XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_XMMu64_AVX512=3889, + XED_IFORM_VPBROADCASTW_XMMdq_MEMw=3890, + XED_IFORM_VPBROADCASTW_XMMdq_XMMw=3891, + XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_GPR32u16_AVX512=3892, + XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_MEMu16_AVX512=3893, + XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_XMMu16_AVX512=3894, + XED_IFORM_VPBROADCASTW_YMMqq_MEMw=3895, + XED_IFORM_VPBROADCASTW_YMMqq_XMMw=3896, + XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_GPR32u16_AVX512=3897, + XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_MEMu16_AVX512=3898, + XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_XMMu16_AVX512=3899, + XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_GPR32u16_AVX512=3900, + XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_MEMu16_AVX512=3901, + XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_XMMu16_AVX512=3902, + XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_MEMdq_IMMb=3903, + XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_XMMdq_IMMb=3904, + XED_IFORM_VPCMOV_XMMdq_XMMdq_MEMdq_XMMdq=3905, + XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_MEMdq=3906, + XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_XMMdq=3907, + XED_IFORM_VPCMOV_YMMqq_YMMqq_MEMqq_YMMqq=3908, + XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_MEMqq=3909, + XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_YMMqq=3910, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_MEMi8_IMM8_AVX512=3911, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_XMMi8_IMM8_AVX512=3912, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_MEMi8_IMM8_AVX512=3913, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_YMMi8_IMM8_AVX512=3914, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_MEMi8_IMM8_AVX512=3915, + XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_ZMMi8_IMM8_AVX512=3916, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_MEMi32_IMM8_AVX512=3917, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_XMMi32_IMM8_AVX512=3918, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_MEMi32_IMM8_AVX512=3919, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_YMMi32_IMM8_AVX512=3920, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_MEMi32_IMM8_AVX512=3921, + XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_IMM8_AVX512=3922, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=3923, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=3924, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=3925, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=3926, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=3927, + XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=3928, + XED_IFORM_VPCMPEQB_XMMdq_XMMdq_MEMdq=3929, + XED_IFORM_VPCMPEQB_XMMdq_XMMdq_XMMdq=3930, + XED_IFORM_VPCMPEQB_YMMqq_YMMqq_MEMqq=3931, + XED_IFORM_VPCMPEQB_YMMqq_YMMqq_YMMqq=3932, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=3933, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=3934, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=3935, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=3936, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=3937, + XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=3938, + XED_IFORM_VPCMPEQD_XMMdq_XMMdq_MEMdq=3939, + XED_IFORM_VPCMPEQD_XMMdq_XMMdq_XMMdq=3940, + XED_IFORM_VPCMPEQD_YMMqq_YMMqq_MEMqq=3941, + XED_IFORM_VPCMPEQD_YMMqq_YMMqq_YMMqq=3942, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=3943, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=3944, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=3945, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=3946, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=3947, + XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=3948, + XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_MEMdq=3949, + XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_XMMdq=3950, + XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_MEMqq=3951, + XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_YMMqq=3952, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=3953, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=3954, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=3955, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=3956, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=3957, + XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=3958, + XED_IFORM_VPCMPEQW_XMMdq_XMMdq_MEMdq=3959, + XED_IFORM_VPCMPEQW_XMMdq_XMMdq_XMMdq=3960, + XED_IFORM_VPCMPEQW_YMMqq_YMMqq_MEMqq=3961, + XED_IFORM_VPCMPEQW_YMMqq_YMMqq_YMMqq=3962, + XED_IFORM_VPCMPESTRI_XMMdq_MEMdq_IMMb=3963, + XED_IFORM_VPCMPESTRI_XMMdq_XMMdq_IMMb=3964, + XED_IFORM_VPCMPESTRM_XMMdq_MEMdq_IMMb=3965, + XED_IFORM_VPCMPESTRM_XMMdq_XMMdq_IMMb=3966, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=3967, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=3968, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=3969, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=3970, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=3971, + XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=3972, + XED_IFORM_VPCMPGTB_XMMdq_XMMdq_MEMdq=3973, + XED_IFORM_VPCMPGTB_XMMdq_XMMdq_XMMdq=3974, + XED_IFORM_VPCMPGTB_YMMqq_YMMqq_MEMqq=3975, + XED_IFORM_VPCMPGTB_YMMqq_YMMqq_YMMqq=3976, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_MEMi32_AVX512=3977, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_XMMi32_AVX512=3978, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_MEMi32_AVX512=3979, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_YMMi32_AVX512=3980, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_MEMi32_AVX512=3981, + XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_AVX512=3982, + XED_IFORM_VPCMPGTD_XMMdq_XMMdq_MEMdq=3983, + XED_IFORM_VPCMPGTD_XMMdq_XMMdq_XMMdq=3984, + XED_IFORM_VPCMPGTD_YMMqq_YMMqq_MEMqq=3985, + XED_IFORM_VPCMPGTD_YMMqq_YMMqq_YMMqq=3986, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_MEMi64_AVX512=3987, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_XMMi64_AVX512=3988, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_MEMi64_AVX512=3989, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_YMMi64_AVX512=3990, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_AVX512=3991, + XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_AVX512=3992, + XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_MEMdq=3993, + XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_XMMdq=3994, + XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_MEMqq=3995, + XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_YMMqq=3996, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=3997, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=3998, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=3999, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=4000, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=4001, + XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=4002, + XED_IFORM_VPCMPGTW_XMMdq_XMMdq_MEMdq=4003, + XED_IFORM_VPCMPGTW_XMMdq_XMMdq_XMMdq=4004, + XED_IFORM_VPCMPGTW_YMMqq_YMMqq_MEMqq=4005, + XED_IFORM_VPCMPGTW_YMMqq_YMMqq_YMMqq=4006, + XED_IFORM_VPCMPISTRI_XMMdq_MEMdq_IMMb=4007, + XED_IFORM_VPCMPISTRI_XMMdq_XMMdq_IMMb=4008, + XED_IFORM_VPCMPISTRM_XMMdq_MEMdq_IMMb=4009, + XED_IFORM_VPCMPISTRM_XMMdq_XMMdq_IMMb=4010, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_MEMi64_IMM8_AVX512=4011, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_XMMi64_IMM8_AVX512=4012, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_MEMi64_IMM8_AVX512=4013, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_YMMi64_IMM8_AVX512=4014, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_IMM8_AVX512=4015, + XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_IMM8_AVX512=4016, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=4017, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=4018, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=4019, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=4020, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=4021, + XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=4022, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=4023, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=4024, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=4025, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=4026, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=4027, + XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=4028, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=4029, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=4030, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=4031, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=4032, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=4033, + XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=4034, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_MEMu16_IMM8_AVX512=4035, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_XMMu16_IMM8_AVX512=4036, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_MEMu16_IMM8_AVX512=4037, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_YMMu16_IMM8_AVX512=4038, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512=4039, + XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512=4040, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_MEMi16_IMM8_AVX512=4041, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_XMMi16_IMM8_AVX512=4042, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_MEMi16_IMM8_AVX512=4043, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_YMMi16_IMM8_AVX512=4044, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_MEMi16_IMM8_AVX512=4045, + XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_ZMMi16_IMM8_AVX512=4046, + XED_IFORM_VPCOMB_XMMdq_XMMdq_MEMdq_IMMb=4047, + XED_IFORM_VPCOMB_XMMdq_XMMdq_XMMdq_IMMb=4048, + XED_IFORM_VPCOMD_XMMdq_XMMdq_MEMdq_IMMb=4049, + XED_IFORM_VPCOMD_XMMdq_XMMdq_XMMdq_IMMb=4050, + XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_XMMu32_AVX512=4051, + XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_YMMu32_AVX512=4052, + XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_ZMMu32_AVX512=4053, + XED_IFORM_VPCOMPRESSD_XMMu32_MASKmskw_XMMu32_AVX512=4054, + XED_IFORM_VPCOMPRESSD_YMMu32_MASKmskw_YMMu32_AVX512=4055, + XED_IFORM_VPCOMPRESSD_ZMMu32_MASKmskw_ZMMu32_AVX512=4056, + XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_XMMu64_AVX512=4057, + XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_YMMu64_AVX512=4058, + XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_ZMMu64_AVX512=4059, + XED_IFORM_VPCOMPRESSQ_XMMu64_MASKmskw_XMMu64_AVX512=4060, + XED_IFORM_VPCOMPRESSQ_YMMu64_MASKmskw_YMMu64_AVX512=4061, + XED_IFORM_VPCOMPRESSQ_ZMMu64_MASKmskw_ZMMu64_AVX512=4062, + XED_IFORM_VPCOMQ_XMMdq_XMMdq_MEMdq_IMMb=4063, + XED_IFORM_VPCOMQ_XMMdq_XMMdq_XMMdq_IMMb=4064, + XED_IFORM_VPCOMUB_XMMdq_XMMdq_MEMdq_IMMb=4065, + XED_IFORM_VPCOMUB_XMMdq_XMMdq_XMMdq_IMMb=4066, + XED_IFORM_VPCOMUD_XMMdq_XMMdq_MEMdq_IMMb=4067, + XED_IFORM_VPCOMUD_XMMdq_XMMdq_XMMdq_IMMb=4068, + XED_IFORM_VPCOMUQ_XMMdq_XMMdq_MEMdq_IMMb=4069, + XED_IFORM_VPCOMUQ_XMMdq_XMMdq_XMMdq_IMMb=4070, + XED_IFORM_VPCOMUW_XMMdq_XMMdq_MEMdq_IMMb=4071, + XED_IFORM_VPCOMUW_XMMdq_XMMdq_XMMdq_IMMb=4072, + XED_IFORM_VPCOMW_XMMdq_XMMdq_MEMdq_IMMb=4073, + XED_IFORM_VPCOMW_XMMdq_XMMdq_XMMdq_IMMb=4074, + XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_MEMu32_AVX512=4075, + XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_XMMu32_AVX512=4076, + XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_MEMu32_AVX512=4077, + XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_YMMu32_AVX512=4078, + XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_MEMu32_AVX512CD=4079, + XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD=4080, + XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_MEMu64_AVX512=4081, + XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_XMMu64_AVX512=4082, + XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_MEMu64_AVX512=4083, + XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_YMMu64_AVX512=4084, + XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD=4085, + XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD=4086, + XED_IFORM_VPERM2F128_YMMqq_YMMqq_MEMqq_IMMb=4087, + XED_IFORM_VPERM2F128_YMMqq_YMMqq_YMMqq_IMMb=4088, + XED_IFORM_VPERM2I128_YMMqq_YMMqq_MEMqq_IMMb=4089, + XED_IFORM_VPERM2I128_YMMqq_YMMqq_YMMqq_IMMb=4090, + XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4091, + XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4092, + XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4093, + XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4094, + XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4095, + XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4096, + XED_IFORM_VPERMD_YMMqq_YMMqq_MEMqq=4097, + XED_IFORM_VPERMD_YMMqq_YMMqq_YMMqq=4098, + XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4099, + XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4100, + XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4101, + XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4102, + XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4103, + XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4104, + XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4105, + XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4106, + XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4107, + XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4108, + XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4109, + XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4110, + XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4111, + XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4112, + XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4113, + XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4114, + XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4115, + XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4116, + XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4117, + XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4118, + XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4119, + XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4120, + XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4121, + XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4122, + XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4123, + XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4124, + XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4125, + XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4126, + XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4127, + XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4128, + XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4129, + XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4130, + XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4131, + XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4132, + XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4133, + XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4134, + XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4135, + XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4136, + XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4137, + XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4138, + XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_MEMdq_XMMdq_IMMb=4139, + XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_MEMdq_IMMb=4140, + XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_XMMdq_IMMb=4141, + XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_MEMqq_YMMqq_IMMb=4142, + XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_MEMqq_IMMb=4143, + XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_YMMqq_IMMb=4144, + XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_MEMdq_XMMdq_IMMb=4145, + XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_MEMdq_IMMb=4146, + XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_XMMdq_IMMb=4147, + XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_MEMqq_YMMqq_IMMb=4148, + XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_MEMqq_IMMb=4149, + XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_YMMqq_IMMb=4150, + XED_IFORM_VPERMILPD_XMMdq_MEMdq_IMMb=4151, + XED_IFORM_VPERMILPD_XMMdq_XMMdq_IMMb=4152, + XED_IFORM_VPERMILPD_XMMdq_XMMdq_MEMdq=4153, + XED_IFORM_VPERMILPD_XMMdq_XMMdq_XMMdq=4154, + XED_IFORM_VPERMILPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=4155, + XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=4156, + XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4157, + XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4158, + XED_IFORM_VPERMILPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=4159, + XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=4160, + XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4161, + XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4162, + XED_IFORM_VPERMILPD_YMMqq_MEMqq_IMMb=4163, + XED_IFORM_VPERMILPD_YMMqq_YMMqq_IMMb=4164, + XED_IFORM_VPERMILPD_YMMqq_YMMqq_MEMqq=4165, + XED_IFORM_VPERMILPD_YMMqq_YMMqq_YMMqq=4166, + XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=4167, + XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=4168, + XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4169, + XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4170, + XED_IFORM_VPERMILPS_XMMdq_MEMdq_IMMb=4171, + XED_IFORM_VPERMILPS_XMMdq_XMMdq_IMMb=4172, + XED_IFORM_VPERMILPS_XMMdq_XMMdq_MEMdq=4173, + XED_IFORM_VPERMILPS_XMMdq_XMMdq_XMMdq=4174, + XED_IFORM_VPERMILPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=4175, + XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=4176, + XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4177, + XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4178, + XED_IFORM_VPERMILPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=4179, + XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=4180, + XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4181, + XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4182, + XED_IFORM_VPERMILPS_YMMqq_MEMqq_IMMb=4183, + XED_IFORM_VPERMILPS_YMMqq_YMMqq_IMMb=4184, + XED_IFORM_VPERMILPS_YMMqq_YMMqq_MEMqq=4185, + XED_IFORM_VPERMILPS_YMMqq_YMMqq_YMMqq=4186, + XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=4187, + XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=4188, + XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4189, + XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4190, + XED_IFORM_VPERMPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=4191, + XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=4192, + XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4193, + XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4194, + XED_IFORM_VPERMPD_YMMqq_MEMqq_IMMb=4195, + XED_IFORM_VPERMPD_YMMqq_YMMqq_IMMb=4196, + XED_IFORM_VPERMPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=4197, + XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=4198, + XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4199, + XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4200, + XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4201, + XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4202, + XED_IFORM_VPERMPS_YMMqq_YMMqq_MEMqq=4203, + XED_IFORM_VPERMPS_YMMqq_YMMqq_YMMqq=4204, + XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4205, + XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4206, + XED_IFORM_VPERMQ_YMMqq_MEMqq_IMMb=4207, + XED_IFORM_VPERMQ_YMMqq_YMMqq_IMMb=4208, + XED_IFORM_VPERMQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=4209, + XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=4210, + XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4211, + XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4212, + XED_IFORM_VPERMQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=4213, + XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=4214, + XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4215, + XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4216, + XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4217, + XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4218, + XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4219, + XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4220, + XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4221, + XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4222, + XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4223, + XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4224, + XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4225, + XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4226, + XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4227, + XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4228, + XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4229, + XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4230, + XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4231, + XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4232, + XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4233, + XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4234, + XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4235, + XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4236, + XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4237, + XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4238, + XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4239, + XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4240, + XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4241, + XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4242, + XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4243, + XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4244, + XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4245, + XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4246, + XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4247, + XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4248, + XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4249, + XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4250, + XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4251, + XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4252, + XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4253, + XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4254, + XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4255, + XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4256, + XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4257, + XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4258, + XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_MEMu32_AVX512=4259, + XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_XMMu32_AVX512=4260, + XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_MEMu32_AVX512=4261, + XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_YMMu32_AVX512=4262, + XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_MEMu32_AVX512=4263, + XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_ZMMu32_AVX512=4264, + XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_MEMu64_AVX512=4265, + XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_XMMu64_AVX512=4266, + XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_MEMu64_AVX512=4267, + XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_YMMu64_AVX512=4268, + XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_MEMu64_AVX512=4269, + XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_ZMMu64_AVX512=4270, + XED_IFORM_VPEXTRB_GPR32d_XMMdq_IMMb=4271, + XED_IFORM_VPEXTRB_GPR32u8_XMMu8_IMM8_AVX512=4272, + XED_IFORM_VPEXTRB_MEMb_XMMdq_IMMb=4273, + XED_IFORM_VPEXTRB_MEMu8_XMMu8_IMM8_AVX512=4274, + XED_IFORM_VPEXTRD_GPR32d_XMMdq_IMMb=4275, + XED_IFORM_VPEXTRD_GPR32u32_XMMu32_IMM8_AVX512=4276, + XED_IFORM_VPEXTRD_MEMd_XMMdq_IMMb=4277, + XED_IFORM_VPEXTRD_MEMu32_XMMu32_IMM8_AVX512=4278, + XED_IFORM_VPEXTRQ_GPR64q_XMMdq_IMMb=4279, + XED_IFORM_VPEXTRQ_GPR64u64_XMMu64_IMM8_AVX512=4280, + XED_IFORM_VPEXTRQ_MEMq_XMMdq_IMMb=4281, + XED_IFORM_VPEXTRQ_MEMu64_XMMu64_IMM8_AVX512=4282, + XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_15=4283, + XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_C5=4284, + XED_IFORM_VPEXTRW_GPR32u16_XMMu16_IMM8_AVX512=4285, + XED_IFORM_VPEXTRW_MEMu16_XMMu16_IMM8_AVX512=4286, + XED_IFORM_VPEXTRW_MEMw_XMMdq_IMMb=4287, + XED_IFORM_VPGATHERDD_XMMu32_MASKmskw_MEMu32_AVX512_VL128=4288, + XED_IFORM_VPGATHERDD_XMMu32_MEMdq_XMMi32_VL128=4289, + XED_IFORM_VPGATHERDD_YMMu32_MASKmskw_MEMu32_AVX512_VL256=4290, + XED_IFORM_VPGATHERDD_YMMu32_MEMqq_YMMi32_VL256=4291, + XED_IFORM_VPGATHERDD_ZMMu32_MASKmskw_MEMu32_AVX512_VL512=4292, + XED_IFORM_VPGATHERDQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128=4293, + XED_IFORM_VPGATHERDQ_XMMu64_MEMdq_XMMi64_VL128=4294, + XED_IFORM_VPGATHERDQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256=4295, + XED_IFORM_VPGATHERDQ_YMMu64_MEMqq_YMMi64_VL256=4296, + XED_IFORM_VPGATHERDQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512=4297, + XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL128=4298, + XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL256=4299, + XED_IFORM_VPGATHERQD_XMMu32_MEMdq_XMMi32_VL256=4300, + XED_IFORM_VPGATHERQD_XMMu32_MEMq_XMMi32_VL128=4301, + XED_IFORM_VPGATHERQD_YMMu32_MASKmskw_MEMu32_AVX512_VL512=4302, + XED_IFORM_VPGATHERQQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128=4303, + XED_IFORM_VPGATHERQQ_XMMu64_MEMdq_XMMi64_VL128=4304, + XED_IFORM_VPGATHERQQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256=4305, + XED_IFORM_VPGATHERQQ_YMMu64_MEMqq_YMMi64_VL256=4306, + XED_IFORM_VPGATHERQQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512=4307, + XED_IFORM_VPHADDBD_XMMdq_MEMdq=4308, + XED_IFORM_VPHADDBD_XMMdq_XMMdq=4309, + XED_IFORM_VPHADDBQ_XMMdq_MEMdq=4310, + XED_IFORM_VPHADDBQ_XMMdq_XMMdq=4311, + XED_IFORM_VPHADDBW_XMMdq_MEMdq=4312, + XED_IFORM_VPHADDBW_XMMdq_XMMdq=4313, + XED_IFORM_VPHADDD_XMMdq_XMMdq_MEMdq=4314, + XED_IFORM_VPHADDD_XMMdq_XMMdq_XMMdq=4315, + XED_IFORM_VPHADDD_YMMqq_YMMqq_MEMqq=4316, + XED_IFORM_VPHADDD_YMMqq_YMMqq_YMMqq=4317, + XED_IFORM_VPHADDDQ_XMMdq_MEMdq=4318, + XED_IFORM_VPHADDDQ_XMMdq_XMMdq=4319, + XED_IFORM_VPHADDSW_XMMdq_XMMdq_MEMdq=4320, + XED_IFORM_VPHADDSW_XMMdq_XMMdq_XMMdq=4321, + XED_IFORM_VPHADDSW_YMMqq_YMMqq_MEMqq=4322, + XED_IFORM_VPHADDSW_YMMqq_YMMqq_YMMqq=4323, + XED_IFORM_VPHADDUBD_XMMdq_MEMdq=4324, + XED_IFORM_VPHADDUBD_XMMdq_XMMdq=4325, + XED_IFORM_VPHADDUBQ_XMMdq_MEMdq=4326, + XED_IFORM_VPHADDUBQ_XMMdq_XMMdq=4327, + XED_IFORM_VPHADDUBW_XMMdq_MEMdq=4328, + XED_IFORM_VPHADDUBW_XMMdq_XMMdq=4329, + XED_IFORM_VPHADDUDQ_XMMdq_MEMdq=4330, + XED_IFORM_VPHADDUDQ_XMMdq_XMMdq=4331, + XED_IFORM_VPHADDUWD_XMMdq_MEMdq=4332, + XED_IFORM_VPHADDUWD_XMMdq_XMMdq=4333, + XED_IFORM_VPHADDUWQ_XMMdq_MEMdq=4334, + XED_IFORM_VPHADDUWQ_XMMdq_XMMdq=4335, + XED_IFORM_VPHADDW_XMMdq_XMMdq_MEMdq=4336, + XED_IFORM_VPHADDW_XMMdq_XMMdq_XMMdq=4337, + XED_IFORM_VPHADDW_YMMqq_YMMqq_MEMqq=4338, + XED_IFORM_VPHADDW_YMMqq_YMMqq_YMMqq=4339, + XED_IFORM_VPHADDWD_XMMdq_MEMdq=4340, + XED_IFORM_VPHADDWD_XMMdq_XMMdq=4341, + XED_IFORM_VPHADDWQ_XMMdq_MEMdq=4342, + XED_IFORM_VPHADDWQ_XMMdq_XMMdq=4343, + XED_IFORM_VPHMINPOSUW_XMMdq_MEMdq=4344, + XED_IFORM_VPHMINPOSUW_XMMdq_XMMdq=4345, + XED_IFORM_VPHMINPOSUW_YMMqq_MEMqq=4346, + XED_IFORM_VPHMINPOSUW_YMMqq_YMMqq=4347, + XED_IFORM_VPHSUBBW_XMMdq_MEMdq=4348, + XED_IFORM_VPHSUBBW_XMMdq_XMMdq=4349, + XED_IFORM_VPHSUBD_XMMdq_XMMdq_MEMdq=4350, + XED_IFORM_VPHSUBD_XMMdq_XMMdq_XMMdq=4351, + XED_IFORM_VPHSUBD_YMMqq_YMMqq_MEMqq=4352, + XED_IFORM_VPHSUBD_YMMqq_YMMqq_YMMqq=4353, + XED_IFORM_VPHSUBDQ_XMMdq_MEMdq=4354, + XED_IFORM_VPHSUBDQ_XMMdq_XMMdq=4355, + XED_IFORM_VPHSUBSW_XMMdq_XMMdq_MEMdq=4356, + XED_IFORM_VPHSUBSW_XMMdq_XMMdq_XMMdq=4357, + XED_IFORM_VPHSUBSW_YMMqq_YMMqq_MEMqq=4358, + XED_IFORM_VPHSUBSW_YMMqq_YMMqq_YMMqq=4359, + XED_IFORM_VPHSUBW_XMMdq_XMMdq_MEMdq=4360, + XED_IFORM_VPHSUBW_XMMdq_XMMdq_XMMdq=4361, + XED_IFORM_VPHSUBW_YMMqq_YMMqq_MEMqq=4362, + XED_IFORM_VPHSUBW_YMMqq_YMMqq_YMMqq=4363, + XED_IFORM_VPHSUBWD_XMMdq_MEMdq=4364, + XED_IFORM_VPHSUBWD_XMMdq_XMMdq=4365, + XED_IFORM_VPINSRB_XMMdq_XMMdq_GPR32d_IMMb=4366, + XED_IFORM_VPINSRB_XMMdq_XMMdq_MEMb_IMMb=4367, + XED_IFORM_VPINSRB_XMMu8_XMMu8_GPR32u8_IMM8_AVX512=4368, + XED_IFORM_VPINSRB_XMMu8_XMMu8_MEMu8_IMM8_AVX512=4369, + XED_IFORM_VPINSRD_XMMdq_XMMdq_GPR32d_IMMb=4370, + XED_IFORM_VPINSRD_XMMdq_XMMdq_MEMd_IMMb=4371, + XED_IFORM_VPINSRD_XMMu32_XMMu32_GPR32u32_IMM8_AVX512=4372, + XED_IFORM_VPINSRD_XMMu32_XMMu32_MEMu32_IMM8_AVX512=4373, + XED_IFORM_VPINSRQ_XMMdq_XMMdq_GPR64q_IMMb=4374, + XED_IFORM_VPINSRQ_XMMdq_XMMdq_MEMq_IMMb=4375, + XED_IFORM_VPINSRQ_XMMu64_XMMu64_GPR64u64_IMM8_AVX512=4376, + XED_IFORM_VPINSRQ_XMMu64_XMMu64_MEMu64_IMM8_AVX512=4377, + XED_IFORM_VPINSRW_XMMdq_XMMdq_GPR32d_IMMb=4378, + XED_IFORM_VPINSRW_XMMdq_XMMdq_MEMw_IMMb=4379, + XED_IFORM_VPINSRW_XMMu16_XMMu16_GPR32u16_IMM8_AVX512=4380, + XED_IFORM_VPINSRW_XMMu16_XMMu16_MEMu16_IMM8_AVX512=4381, + XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_MEMu32_AVX512=4382, + XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_XMMu32_AVX512=4383, + XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_MEMu32_AVX512=4384, + XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_YMMu32_AVX512=4385, + XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_MEMu32_AVX512CD=4386, + XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD=4387, + XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_MEMu64_AVX512=4388, + XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_XMMu64_AVX512=4389, + XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_MEMu64_AVX512=4390, + XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_YMMu64_AVX512=4391, + XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD=4392, + XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD=4393, + XED_IFORM_VPMACSDD_XMMdq_XMMdq_MEMdq_XMMdq=4394, + XED_IFORM_VPMACSDD_XMMdq_XMMdq_XMMdq_XMMdq=4395, + XED_IFORM_VPMACSDQH_XMMdq_XMMdq_MEMdq_XMMdq=4396, + XED_IFORM_VPMACSDQH_XMMdq_XMMdq_XMMdq_XMMdq=4397, + XED_IFORM_VPMACSDQL_XMMdq_XMMdq_MEMdq_XMMdq=4398, + XED_IFORM_VPMACSDQL_XMMdq_XMMdq_XMMdq_XMMdq=4399, + XED_IFORM_VPMACSSDD_XMMdq_XMMdq_MEMdq_XMMdq=4400, + XED_IFORM_VPMACSSDD_XMMdq_XMMdq_XMMdq_XMMdq=4401, + XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_MEMdq_XMMdq=4402, + XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_XMMdq_XMMdq=4403, + XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_MEMdq_XMMdq=4404, + XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_XMMdq_XMMdq=4405, + XED_IFORM_VPMACSSWD_XMMdq_XMMdq_MEMdq_XMMdq=4406, + XED_IFORM_VPMACSSWD_XMMdq_XMMdq_XMMdq_XMMdq=4407, + XED_IFORM_VPMACSSWW_XMMdq_XMMdq_MEMdq_XMMdq=4408, + XED_IFORM_VPMACSSWW_XMMdq_XMMdq_XMMdq_XMMdq=4409, + XED_IFORM_VPMACSWD_XMMdq_XMMdq_MEMdq_XMMdq=4410, + XED_IFORM_VPMACSWD_XMMdq_XMMdq_XMMdq_XMMdq=4411, + XED_IFORM_VPMACSWW_XMMdq_XMMdq_MEMdq_XMMdq=4412, + XED_IFORM_VPMACSWW_XMMdq_XMMdq_XMMdq_XMMdq=4413, + XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_MEMdq_XMMdq=4414, + XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_XMMdq_XMMdq=4415, + XED_IFORM_VPMADCSWD_XMMdq_XMMdq_MEMdq_XMMdq=4416, + XED_IFORM_VPMADCSWD_XMMdq_XMMdq_XMMdq_XMMdq=4417, + XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4418, + XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4419, + XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4420, + XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4421, + XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4422, + XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4423, + XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4424, + XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4425, + XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4426, + XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4427, + XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4428, + XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4429, + XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_MEMdq=4430, + XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_XMMdq=4431, + XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=4432, + XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=4433, + XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=4434, + XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=4435, + XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_MEMqq=4436, + XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_YMMqq=4437, + XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=4438, + XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=4439, + XED_IFORM_VPMADDWD_XMMdq_XMMdq_MEMdq=4440, + XED_IFORM_VPMADDWD_XMMdq_XMMdq_XMMdq=4441, + XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_MEMi16_AVX512=4442, + XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_XMMi16_AVX512=4443, + XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_MEMi16_AVX512=4444, + XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_YMMi16_AVX512=4445, + XED_IFORM_VPMADDWD_YMMqq_YMMqq_MEMqq=4446, + XED_IFORM_VPMADDWD_YMMqq_YMMqq_YMMqq=4447, + XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_MEMi16_AVX512=4448, + XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_ZMMi16_AVX512=4449, + XED_IFORM_VPMASKMOVD_MEMdq_XMMdq_XMMdq=4450, + XED_IFORM_VPMASKMOVD_MEMqq_YMMqq_YMMqq=4451, + XED_IFORM_VPMASKMOVD_XMMdq_XMMdq_MEMdq=4452, + XED_IFORM_VPMASKMOVD_YMMqq_YMMqq_MEMqq=4453, + XED_IFORM_VPMASKMOVQ_MEMdq_XMMdq_XMMdq=4454, + XED_IFORM_VPMASKMOVQ_MEMqq_YMMqq_YMMqq=4455, + XED_IFORM_VPMASKMOVQ_XMMdq_XMMdq_MEMdq=4456, + XED_IFORM_VPMASKMOVQ_YMMqq_YMMqq_MEMqq=4457, + XED_IFORM_VPMAXSB_XMMdq_XMMdq_MEMdq=4458, + XED_IFORM_VPMAXSB_XMMdq_XMMdq_XMMdq=4459, + XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=4460, + XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=4461, + XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=4462, + XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=4463, + XED_IFORM_VPMAXSB_YMMqq_YMMqq_MEMqq=4464, + XED_IFORM_VPMAXSB_YMMqq_YMMqq_YMMqq=4465, + XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=4466, + XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=4467, + XED_IFORM_VPMAXSD_XMMdq_XMMdq_MEMdq=4468, + XED_IFORM_VPMAXSD_XMMdq_XMMdq_XMMdq=4469, + XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512=4470, + XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512=4471, + XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512=4472, + XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512=4473, + XED_IFORM_VPMAXSD_YMMqq_YMMqq_MEMqq=4474, + XED_IFORM_VPMAXSD_YMMqq_YMMqq_YMMqq=4475, + XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512=4476, + XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512=4477, + XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512=4478, + XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512=4479, + XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512=4480, + XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512=4481, + XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512=4482, + XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512=4483, + XED_IFORM_VPMAXSW_XMMdq_XMMdq_MEMdq=4484, + XED_IFORM_VPMAXSW_XMMdq_XMMdq_XMMdq=4485, + XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=4486, + XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=4487, + XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=4488, + XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=4489, + XED_IFORM_VPMAXSW_YMMqq_YMMqq_MEMqq=4490, + XED_IFORM_VPMAXSW_YMMqq_YMMqq_YMMqq=4491, + XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=4492, + XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=4493, + XED_IFORM_VPMAXUB_XMMdq_XMMdq_MEMdq=4494, + XED_IFORM_VPMAXUB_XMMdq_XMMdq_XMMdq=4495, + XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4496, + XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4497, + XED_IFORM_VPMAXUB_YMMqq_YMMqq_MEMqq=4498, + XED_IFORM_VPMAXUB_YMMqq_YMMqq_YMMqq=4499, + XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4500, + XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4501, + XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4502, + XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4503, + XED_IFORM_VPMAXUD_XMMdq_XMMdq_MEMdq=4504, + XED_IFORM_VPMAXUD_XMMdq_XMMdq_XMMdq=4505, + XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4506, + XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4507, + XED_IFORM_VPMAXUD_YMMqq_YMMqq_MEMqq=4508, + XED_IFORM_VPMAXUD_YMMqq_YMMqq_YMMqq=4509, + XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4510, + XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4511, + XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4512, + XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4513, + XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4514, + XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4515, + XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4516, + XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4517, + XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4518, + XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4519, + XED_IFORM_VPMAXUW_XMMdq_XMMdq_MEMdq=4520, + XED_IFORM_VPMAXUW_XMMdq_XMMdq_XMMdq=4521, + XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4522, + XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4523, + XED_IFORM_VPMAXUW_YMMqq_YMMqq_MEMqq=4524, + XED_IFORM_VPMAXUW_YMMqq_YMMqq_YMMqq=4525, + XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4526, + XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4527, + XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4528, + XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4529, + XED_IFORM_VPMINSB_XMMdq_XMMdq_MEMdq=4530, + XED_IFORM_VPMINSB_XMMdq_XMMdq_XMMdq=4531, + XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=4532, + XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=4533, + XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=4534, + XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=4535, + XED_IFORM_VPMINSB_YMMqq_YMMqq_MEMqq=4536, + XED_IFORM_VPMINSB_YMMqq_YMMqq_YMMqq=4537, + XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=4538, + XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=4539, + XED_IFORM_VPMINSD_XMMdq_XMMdq_MEMdq=4540, + XED_IFORM_VPMINSD_XMMdq_XMMdq_XMMdq=4541, + XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512=4542, + XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512=4543, + XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512=4544, + XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512=4545, + XED_IFORM_VPMINSD_YMMqq_YMMqq_MEMqq=4546, + XED_IFORM_VPMINSD_YMMqq_YMMqq_YMMqq=4547, + XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512=4548, + XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512=4549, + XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512=4550, + XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512=4551, + XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512=4552, + XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512=4553, + XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512=4554, + XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512=4555, + XED_IFORM_VPMINSW_XMMdq_XMMdq_MEMdq=4556, + XED_IFORM_VPMINSW_XMMdq_XMMdq_XMMdq=4557, + XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=4558, + XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=4559, + XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=4560, + XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=4561, + XED_IFORM_VPMINSW_YMMqq_YMMqq_MEMqq=4562, + XED_IFORM_VPMINSW_YMMqq_YMMqq_YMMqq=4563, + XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=4564, + XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=4565, + XED_IFORM_VPMINUB_XMMdq_XMMdq_MEMdq=4566, + XED_IFORM_VPMINUB_XMMdq_XMMdq_XMMdq=4567, + XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4568, + XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4569, + XED_IFORM_VPMINUB_YMMqq_YMMqq_MEMqq=4570, + XED_IFORM_VPMINUB_YMMqq_YMMqq_YMMqq=4571, + XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4572, + XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4573, + XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4574, + XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4575, + XED_IFORM_VPMINUD_XMMdq_XMMdq_MEMdq=4576, + XED_IFORM_VPMINUD_XMMdq_XMMdq_XMMdq=4577, + XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4578, + XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4579, + XED_IFORM_VPMINUD_YMMqq_YMMqq_MEMqq=4580, + XED_IFORM_VPMINUD_YMMqq_YMMqq_YMMqq=4581, + XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4582, + XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4583, + XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4584, + XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4585, + XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4586, + XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4587, + XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4588, + XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4589, + XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4590, + XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4591, + XED_IFORM_VPMINUW_XMMdq_XMMdq_MEMdq=4592, + XED_IFORM_VPMINUW_XMMdq_XMMdq_XMMdq=4593, + XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4594, + XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4595, + XED_IFORM_VPMINUW_YMMqq_YMMqq_MEMqq=4596, + XED_IFORM_VPMINUW_YMMqq_YMMqq_YMMqq=4597, + XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4598, + XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4599, + XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4600, + XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4601, + XED_IFORM_VPMOVB2M_MASKmskw_XMMu8_AVX512=4602, + XED_IFORM_VPMOVB2M_MASKmskw_YMMu8_AVX512=4603, + XED_IFORM_VPMOVB2M_MASKmskw_ZMMu8_AVX512=4604, + XED_IFORM_VPMOVD2M_MASKmskw_XMMu32_AVX512=4605, + XED_IFORM_VPMOVD2M_MASKmskw_YMMu32_AVX512=4606, + XED_IFORM_VPMOVD2M_MASKmskw_ZMMu32_AVX512=4607, + XED_IFORM_VPMOVDB_MEMu8_MASKmskw_XMMu32_AVX512=4608, + XED_IFORM_VPMOVDB_MEMu8_MASKmskw_YMMu32_AVX512=4609, + XED_IFORM_VPMOVDB_MEMu8_MASKmskw_ZMMu32_AVX512=4610, + XED_IFORM_VPMOVDB_XMMu8_MASKmskw_XMMu32_AVX512=4611, + XED_IFORM_VPMOVDB_XMMu8_MASKmskw_YMMu32_AVX512=4612, + XED_IFORM_VPMOVDB_XMMu8_MASKmskw_ZMMu32_AVX512=4613, + XED_IFORM_VPMOVDW_MEMu16_MASKmskw_XMMu32_AVX512=4614, + XED_IFORM_VPMOVDW_MEMu16_MASKmskw_YMMu32_AVX512=4615, + XED_IFORM_VPMOVDW_MEMu16_MASKmskw_ZMMu32_AVX512=4616, + XED_IFORM_VPMOVDW_XMMu16_MASKmskw_XMMu32_AVX512=4617, + XED_IFORM_VPMOVDW_XMMu16_MASKmskw_YMMu32_AVX512=4618, + XED_IFORM_VPMOVDW_YMMu16_MASKmskw_ZMMu32_AVX512=4619, + XED_IFORM_VPMOVM2B_XMMu8_MASKmskw_AVX512=4620, + XED_IFORM_VPMOVM2B_YMMu8_MASKmskw_AVX512=4621, + XED_IFORM_VPMOVM2B_ZMMu8_MASKmskw_AVX512=4622, + XED_IFORM_VPMOVM2D_XMMu32_MASKmskw_AVX512=4623, + XED_IFORM_VPMOVM2D_YMMu32_MASKmskw_AVX512=4624, + XED_IFORM_VPMOVM2D_ZMMu32_MASKmskw_AVX512=4625, + XED_IFORM_VPMOVM2Q_XMMu64_MASKmskw_AVX512=4626, + XED_IFORM_VPMOVM2Q_YMMu64_MASKmskw_AVX512=4627, + XED_IFORM_VPMOVM2Q_ZMMu64_MASKmskw_AVX512=4628, + XED_IFORM_VPMOVM2W_XMMu16_MASKmskw_AVX512=4629, + XED_IFORM_VPMOVM2W_YMMu16_MASKmskw_AVX512=4630, + XED_IFORM_VPMOVM2W_ZMMu16_MASKmskw_AVX512=4631, + XED_IFORM_VPMOVMSKB_GPR32d_XMMdq=4632, + XED_IFORM_VPMOVMSKB_GPR32d_YMMqq=4633, + XED_IFORM_VPMOVQ2M_MASKmskw_XMMu64_AVX512=4634, + XED_IFORM_VPMOVQ2M_MASKmskw_YMMu64_AVX512=4635, + XED_IFORM_VPMOVQ2M_MASKmskw_ZMMu64_AVX512=4636, + XED_IFORM_VPMOVQB_MEMu8_MASKmskw_XMMu64_AVX512=4637, + XED_IFORM_VPMOVQB_MEMu8_MASKmskw_YMMu64_AVX512=4638, + XED_IFORM_VPMOVQB_MEMu8_MASKmskw_ZMMu64_AVX512=4639, + XED_IFORM_VPMOVQB_XMMu8_MASKmskw_XMMu64_AVX512=4640, + XED_IFORM_VPMOVQB_XMMu8_MASKmskw_YMMu64_AVX512=4641, + XED_IFORM_VPMOVQB_XMMu8_MASKmskw_ZMMu64_AVX512=4642, + XED_IFORM_VPMOVQD_MEMu32_MASKmskw_XMMu64_AVX512=4643, + XED_IFORM_VPMOVQD_MEMu32_MASKmskw_YMMu64_AVX512=4644, + XED_IFORM_VPMOVQD_MEMu32_MASKmskw_ZMMu64_AVX512=4645, + XED_IFORM_VPMOVQD_XMMu32_MASKmskw_XMMu64_AVX512=4646, + XED_IFORM_VPMOVQD_XMMu32_MASKmskw_YMMu64_AVX512=4647, + XED_IFORM_VPMOVQD_YMMu32_MASKmskw_ZMMu64_AVX512=4648, + XED_IFORM_VPMOVQW_MEMu16_MASKmskw_XMMu64_AVX512=4649, + XED_IFORM_VPMOVQW_MEMu16_MASKmskw_YMMu64_AVX512=4650, + XED_IFORM_VPMOVQW_MEMu16_MASKmskw_ZMMu64_AVX512=4651, + XED_IFORM_VPMOVQW_XMMu16_MASKmskw_XMMu64_AVX512=4652, + XED_IFORM_VPMOVQW_XMMu16_MASKmskw_YMMu64_AVX512=4653, + XED_IFORM_VPMOVQW_XMMu16_MASKmskw_ZMMu64_AVX512=4654, + XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_XMMi32_AVX512=4655, + XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_YMMi32_AVX512=4656, + XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_ZMMi32_AVX512=4657, + XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_XMMi32_AVX512=4658, + XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_YMMi32_AVX512=4659, + XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_ZMMi32_AVX512=4660, + XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_XMMi32_AVX512=4661, + XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_YMMi32_AVX512=4662, + XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_ZMMi32_AVX512=4663, + XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_XMMi32_AVX512=4664, + XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_YMMi32_AVX512=4665, + XED_IFORM_VPMOVSDW_YMMi16_MASKmskw_ZMMi32_AVX512=4666, + XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_XMMi64_AVX512=4667, + XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_YMMi64_AVX512=4668, + XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_ZMMi64_AVX512=4669, + XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_XMMi64_AVX512=4670, + XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_YMMi64_AVX512=4671, + XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_ZMMi64_AVX512=4672, + XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_XMMi64_AVX512=4673, + XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_YMMi64_AVX512=4674, + XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_ZMMi64_AVX512=4675, + XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_XMMi64_AVX512=4676, + XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_YMMi64_AVX512=4677, + XED_IFORM_VPMOVSQD_YMMi32_MASKmskw_ZMMi64_AVX512=4678, + XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_XMMi64_AVX512=4679, + XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_YMMi64_AVX512=4680, + XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_ZMMi64_AVX512=4681, + XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_XMMi64_AVX512=4682, + XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_YMMi64_AVX512=4683, + XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_ZMMi64_AVX512=4684, + XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_XMMi16_AVX512=4685, + XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_YMMi16_AVX512=4686, + XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_ZMMi16_AVX512=4687, + XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_XMMi16_AVX512=4688, + XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_YMMi16_AVX512=4689, + XED_IFORM_VPMOVSWB_YMMi8_MASKmskw_ZMMi16_AVX512=4690, + XED_IFORM_VPMOVSXBD_XMMdq_MEMd=4691, + XED_IFORM_VPMOVSXBD_XMMdq_XMMd=4692, + XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_MEMi8_AVX512=4693, + XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_XMMi8_AVX512=4694, + XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_MEMi8_AVX512=4695, + XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_XMMi8_AVX512=4696, + XED_IFORM_VPMOVSXBD_YMMqq_MEMq=4697, + XED_IFORM_VPMOVSXBD_YMMqq_XMMq=4698, + XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_MEMi8_AVX512=4699, + XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_XMMi8_AVX512=4700, + XED_IFORM_VPMOVSXBQ_XMMdq_MEMw=4701, + XED_IFORM_VPMOVSXBQ_XMMdq_XMMw=4702, + XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_MEMi8_AVX512=4703, + XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_XMMi8_AVX512=4704, + XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_MEMi8_AVX512=4705, + XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_XMMi8_AVX512=4706, + XED_IFORM_VPMOVSXBQ_YMMqq_MEMd=4707, + XED_IFORM_VPMOVSXBQ_YMMqq_XMMd=4708, + XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_MEMi8_AVX512=4709, + XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_XMMi8_AVX512=4710, + XED_IFORM_VPMOVSXBW_XMMdq_MEMq=4711, + XED_IFORM_VPMOVSXBW_XMMdq_XMMq=4712, + XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_MEMi8_AVX512=4713, + XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_XMMi8_AVX512=4714, + XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_MEMi8_AVX512=4715, + XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_XMMi8_AVX512=4716, + XED_IFORM_VPMOVSXBW_YMMqq_MEMdq=4717, + XED_IFORM_VPMOVSXBW_YMMqq_XMMdq=4718, + XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_MEMi8_AVX512=4719, + XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_YMMi8_AVX512=4720, + XED_IFORM_VPMOVSXDQ_XMMdq_MEMq=4721, + XED_IFORM_VPMOVSXDQ_XMMdq_XMMq=4722, + XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_MEMi32_AVX512=4723, + XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_XMMi32_AVX512=4724, + XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_MEMi32_AVX512=4725, + XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_XMMi32_AVX512=4726, + XED_IFORM_VPMOVSXDQ_YMMqq_MEMdq=4727, + XED_IFORM_VPMOVSXDQ_YMMqq_XMMdq=4728, + XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_MEMi32_AVX512=4729, + XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_YMMi32_AVX512=4730, + XED_IFORM_VPMOVSXWD_XMMdq_MEMq=4731, + XED_IFORM_VPMOVSXWD_XMMdq_XMMq=4732, + XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_MEMi16_AVX512=4733, + XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_XMMi16_AVX512=4734, + XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_MEMi16_AVX512=4735, + XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_XMMi16_AVX512=4736, + XED_IFORM_VPMOVSXWD_YMMqq_MEMdq=4737, + XED_IFORM_VPMOVSXWD_YMMqq_XMMdq=4738, + XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_MEMi16_AVX512=4739, + XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_YMMi16_AVX512=4740, + XED_IFORM_VPMOVSXWQ_XMMdq_MEMd=4741, + XED_IFORM_VPMOVSXWQ_XMMdq_XMMd=4742, + XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_MEMi16_AVX512=4743, + XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_XMMi16_AVX512=4744, + XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_MEMi16_AVX512=4745, + XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_XMMi16_AVX512=4746, + XED_IFORM_VPMOVSXWQ_YMMqq_MEMq=4747, + XED_IFORM_VPMOVSXWQ_YMMqq_XMMq=4748, + XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_MEMi16_AVX512=4749, + XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_XMMi16_AVX512=4750, + XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_XMMu32_AVX512=4751, + XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_YMMu32_AVX512=4752, + XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_ZMMu32_AVX512=4753, + XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_XMMu32_AVX512=4754, + XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_YMMu32_AVX512=4755, + XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_ZMMu32_AVX512=4756, + XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_XMMu32_AVX512=4757, + XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_YMMu32_AVX512=4758, + XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_ZMMu32_AVX512=4759, + XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_XMMu32_AVX512=4760, + XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_YMMu32_AVX512=4761, + XED_IFORM_VPMOVUSDW_YMMu16_MASKmskw_ZMMu32_AVX512=4762, + XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_XMMu64_AVX512=4763, + XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_YMMu64_AVX512=4764, + XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_ZMMu64_AVX512=4765, + XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_XMMu64_AVX512=4766, + XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_YMMu64_AVX512=4767, + XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_ZMMu64_AVX512=4768, + XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_XMMu64_AVX512=4769, + XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_YMMu64_AVX512=4770, + XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_ZMMu64_AVX512=4771, + XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_XMMu64_AVX512=4772, + XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_YMMu64_AVX512=4773, + XED_IFORM_VPMOVUSQD_YMMu32_MASKmskw_ZMMu64_AVX512=4774, + XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_XMMu64_AVX512=4775, + XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_YMMu64_AVX512=4776, + XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_ZMMu64_AVX512=4777, + XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_XMMu64_AVX512=4778, + XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_YMMu64_AVX512=4779, + XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_ZMMu64_AVX512=4780, + XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_XMMu16_AVX512=4781, + XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_YMMu16_AVX512=4782, + XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_ZMMu16_AVX512=4783, + XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_XMMu16_AVX512=4784, + XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_YMMu16_AVX512=4785, + XED_IFORM_VPMOVUSWB_YMMu8_MASKmskw_ZMMu16_AVX512=4786, + XED_IFORM_VPMOVW2M_MASKmskw_XMMu16_AVX512=4787, + XED_IFORM_VPMOVW2M_MASKmskw_YMMu16_AVX512=4788, + XED_IFORM_VPMOVW2M_MASKmskw_ZMMu16_AVX512=4789, + XED_IFORM_VPMOVWB_MEMu8_MASKmskw_XMMu16_AVX512=4790, + XED_IFORM_VPMOVWB_MEMu8_MASKmskw_YMMu16_AVX512=4791, + XED_IFORM_VPMOVWB_MEMu8_MASKmskw_ZMMu16_AVX512=4792, + XED_IFORM_VPMOVWB_XMMu8_MASKmskw_XMMu16_AVX512=4793, + XED_IFORM_VPMOVWB_XMMu8_MASKmskw_YMMu16_AVX512=4794, + XED_IFORM_VPMOVWB_YMMu8_MASKmskw_ZMMu16_AVX512=4795, + XED_IFORM_VPMOVZXBD_XMMdq_MEMd=4796, + XED_IFORM_VPMOVZXBD_XMMdq_XMMd=4797, + XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_MEMi8_AVX512=4798, + XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_XMMi8_AVX512=4799, + XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_MEMi8_AVX512=4800, + XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_XMMi8_AVX512=4801, + XED_IFORM_VPMOVZXBD_YMMqq_MEMq=4802, + XED_IFORM_VPMOVZXBD_YMMqq_XMMq=4803, + XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_MEMi8_AVX512=4804, + XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_XMMi8_AVX512=4805, + XED_IFORM_VPMOVZXBQ_XMMdq_MEMw=4806, + XED_IFORM_VPMOVZXBQ_XMMdq_XMMw=4807, + XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_MEMi8_AVX512=4808, + XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_XMMi8_AVX512=4809, + XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_MEMi8_AVX512=4810, + XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_XMMi8_AVX512=4811, + XED_IFORM_VPMOVZXBQ_YMMqq_MEMd=4812, + XED_IFORM_VPMOVZXBQ_YMMqq_XMMd=4813, + XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_MEMi8_AVX512=4814, + XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_XMMi8_AVX512=4815, + XED_IFORM_VPMOVZXBW_XMMdq_MEMq=4816, + XED_IFORM_VPMOVZXBW_XMMdq_XMMq=4817, + XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_MEMi8_AVX512=4818, + XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_XMMi8_AVX512=4819, + XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_MEMi8_AVX512=4820, + XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_XMMi8_AVX512=4821, + XED_IFORM_VPMOVZXBW_YMMqq_MEMdq=4822, + XED_IFORM_VPMOVZXBW_YMMqq_XMMdq=4823, + XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_MEMi8_AVX512=4824, + XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_YMMi8_AVX512=4825, + XED_IFORM_VPMOVZXDQ_XMMdq_MEMq=4826, + XED_IFORM_VPMOVZXDQ_XMMdq_XMMq=4827, + XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_MEMi32_AVX512=4828, + XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_XMMi32_AVX512=4829, + XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_MEMi32_AVX512=4830, + XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_XMMi32_AVX512=4831, + XED_IFORM_VPMOVZXDQ_YMMqq_MEMdq=4832, + XED_IFORM_VPMOVZXDQ_YMMqq_XMMdq=4833, + XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_MEMi32_AVX512=4834, + XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_YMMi32_AVX512=4835, + XED_IFORM_VPMOVZXWD_XMMdq_MEMq=4836, + XED_IFORM_VPMOVZXWD_XMMdq_XMMq=4837, + XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_MEMi16_AVX512=4838, + XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_XMMi16_AVX512=4839, + XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_MEMi16_AVX512=4840, + XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_XMMi16_AVX512=4841, + XED_IFORM_VPMOVZXWD_YMMqq_MEMdq=4842, + XED_IFORM_VPMOVZXWD_YMMqq_XMMdq=4843, + XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_MEMi16_AVX512=4844, + XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_YMMi16_AVX512=4845, + XED_IFORM_VPMOVZXWQ_XMMdq_MEMd=4846, + XED_IFORM_VPMOVZXWQ_XMMdq_XMMd=4847, + XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_MEMi16_AVX512=4848, + XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_XMMi16_AVX512=4849, + XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_MEMi16_AVX512=4850, + XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_XMMi16_AVX512=4851, + XED_IFORM_VPMOVZXWQ_YMMqq_MEMq=4852, + XED_IFORM_VPMOVZXWQ_YMMqq_XMMq=4853, + XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_MEMi16_AVX512=4854, + XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_XMMi16_AVX512=4855, + XED_IFORM_VPMULDQ_XMMdq_XMMdq_MEMdq=4856, + XED_IFORM_VPMULDQ_XMMdq_XMMdq_XMMdq=4857, + XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_MEMi32_AVX512=4858, + XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_XMMi32_AVX512=4859, + XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_MEMi32_AVX512=4860, + XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_YMMi32_AVX512=4861, + XED_IFORM_VPMULDQ_YMMqq_YMMqq_MEMqq=4862, + XED_IFORM_VPMULDQ_YMMqq_YMMqq_YMMqq=4863, + XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_MEMi32_AVX512=4864, + XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_ZMMi32_AVX512=4865, + XED_IFORM_VPMULHRSW_XMMdq_XMMdq_MEMdq=4866, + XED_IFORM_VPMULHRSW_XMMdq_XMMdq_XMMdq=4867, + XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=4868, + XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=4869, + XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=4870, + XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=4871, + XED_IFORM_VPMULHRSW_YMMqq_YMMqq_MEMqq=4872, + XED_IFORM_VPMULHRSW_YMMqq_YMMqq_YMMqq=4873, + XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=4874, + XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=4875, + XED_IFORM_VPMULHUW_XMMdq_XMMdq_MEMdq=4876, + XED_IFORM_VPMULHUW_XMMdq_XMMdq_XMMdq=4877, + XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4878, + XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4879, + XED_IFORM_VPMULHUW_YMMqq_YMMqq_MEMqq=4880, + XED_IFORM_VPMULHUW_YMMqq_YMMqq_YMMqq=4881, + XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4882, + XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4883, + XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4884, + XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4885, + XED_IFORM_VPMULHW_XMMdq_XMMdq_MEMdq=4886, + XED_IFORM_VPMULHW_XMMdq_XMMdq_XMMdq=4887, + XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4888, + XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4889, + XED_IFORM_VPMULHW_YMMqq_YMMqq_MEMqq=4890, + XED_IFORM_VPMULHW_YMMqq_YMMqq_YMMqq=4891, + XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4892, + XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4893, + XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4894, + XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4895, + XED_IFORM_VPMULLD_XMMdq_XMMdq_MEMdq=4896, + XED_IFORM_VPMULLD_XMMdq_XMMdq_XMMdq=4897, + XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4898, + XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4899, + XED_IFORM_VPMULLD_YMMqq_YMMqq_MEMqq=4900, + XED_IFORM_VPMULLD_YMMqq_YMMqq_YMMqq=4901, + XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4902, + XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4903, + XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4904, + XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4905, + XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4906, + XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4907, + XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4908, + XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4909, + XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4910, + XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4911, + XED_IFORM_VPMULLW_XMMdq_XMMdq_MEMdq=4912, + XED_IFORM_VPMULLW_XMMdq_XMMdq_XMMdq=4913, + XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4914, + XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4915, + XED_IFORM_VPMULLW_YMMqq_YMMqq_MEMqq=4916, + XED_IFORM_VPMULLW_YMMqq_YMMqq_YMMqq=4917, + XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4918, + XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4919, + XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4920, + XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4921, + XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_MEMu64_AVX512=4922, + XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_XMMu64_AVX512=4923, + XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_MEMu64_AVX512=4924, + XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_YMMu64_AVX512=4925, + XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_AVX512=4926, + XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_AVX512=4927, + XED_IFORM_VPMULUDQ_XMMdq_XMMdq_MEMdq=4928, + XED_IFORM_VPMULUDQ_XMMdq_XMMdq_XMMdq=4929, + XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_MEMu32_AVX512=4930, + XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_XMMu32_AVX512=4931, + XED_IFORM_VPMULUDQ_YMMqq_YMMqq_MEMqq=4932, + XED_IFORM_VPMULUDQ_YMMqq_YMMqq_YMMqq=4933, + XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_MEMu32_AVX512=4934, + XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_YMMu32_AVX512=4935, + XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_MEMu32_AVX512=4936, + XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_ZMMu32_AVX512=4937, + XED_IFORM_VPOR_XMMdq_XMMdq_MEMdq=4938, + XED_IFORM_VPOR_XMMdq_XMMdq_XMMdq=4939, + XED_IFORM_VPOR_YMMqq_YMMqq_MEMqq=4940, + XED_IFORM_VPOR_YMMqq_YMMqq_YMMqq=4941, + XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4942, + XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4943, + XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4944, + XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4945, + XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4946, + XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4947, + XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4948, + XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4949, + XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4950, + XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4951, + XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4952, + XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4953, + XED_IFORM_VPPERM_XMMdq_XMMdq_MEMdq_XMMdq=4954, + XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_MEMdq=4955, + XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_XMMdq=4956, + XED_IFORM_VPROLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=4957, + XED_IFORM_VPROLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=4958, + XED_IFORM_VPROLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=4959, + XED_IFORM_VPROLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=4960, + XED_IFORM_VPROLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=4961, + XED_IFORM_VPROLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=4962, + XED_IFORM_VPROLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=4963, + XED_IFORM_VPROLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=4964, + XED_IFORM_VPROLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=4965, + XED_IFORM_VPROLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=4966, + XED_IFORM_VPROLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=4967, + XED_IFORM_VPROLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=4968, + XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4969, + XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4970, + XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4971, + XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4972, + XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4973, + XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4974, + XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4975, + XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4976, + XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4977, + XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4978, + XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4979, + XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4980, + XED_IFORM_VPRORD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=4981, + XED_IFORM_VPRORD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=4982, + XED_IFORM_VPRORD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=4983, + XED_IFORM_VPRORD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=4984, + XED_IFORM_VPRORD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=4985, + XED_IFORM_VPRORD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=4986, + XED_IFORM_VPRORQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=4987, + XED_IFORM_VPRORQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=4988, + XED_IFORM_VPRORQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=4989, + XED_IFORM_VPRORQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=4990, + XED_IFORM_VPRORQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=4991, + XED_IFORM_VPRORQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=4992, + XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4993, + XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4994, + XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4995, + XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4996, + XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4997, + XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4998, + XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4999, + XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5000, + XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5001, + XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5002, + XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5003, + XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5004, + XED_IFORM_VPROTB_XMMdq_MEMdq_IMMb=5005, + XED_IFORM_VPROTB_XMMdq_MEMdq_XMMdq=5006, + XED_IFORM_VPROTB_XMMdq_XMMdq_IMMb=5007, + XED_IFORM_VPROTB_XMMdq_XMMdq_MEMdq=5008, + XED_IFORM_VPROTB_XMMdq_XMMdq_XMMdq=5009, + XED_IFORM_VPROTD_XMMdq_MEMdq_IMMb=5010, + XED_IFORM_VPROTD_XMMdq_MEMdq_XMMdq=5011, + XED_IFORM_VPROTD_XMMdq_XMMdq_IMMb=5012, + XED_IFORM_VPROTD_XMMdq_XMMdq_MEMdq=5013, + XED_IFORM_VPROTD_XMMdq_XMMdq_XMMdq=5014, + XED_IFORM_VPROTQ_XMMdq_MEMdq_IMMb=5015, + XED_IFORM_VPROTQ_XMMdq_MEMdq_XMMdq=5016, + XED_IFORM_VPROTQ_XMMdq_XMMdq_IMMb=5017, + XED_IFORM_VPROTQ_XMMdq_XMMdq_MEMdq=5018, + XED_IFORM_VPROTQ_XMMdq_XMMdq_XMMdq=5019, + XED_IFORM_VPROTW_XMMdq_MEMdq_IMMb=5020, + XED_IFORM_VPROTW_XMMdq_MEMdq_XMMdq=5021, + XED_IFORM_VPROTW_XMMdq_XMMdq_IMMb=5022, + XED_IFORM_VPROTW_XMMdq_XMMdq_MEMdq=5023, + XED_IFORM_VPROTW_XMMdq_XMMdq_XMMdq=5024, + XED_IFORM_VPSADBW_XMMdq_XMMdq_MEMdq=5025, + XED_IFORM_VPSADBW_XMMdq_XMMdq_XMMdq=5026, + XED_IFORM_VPSADBW_XMMu16_XMMu8_MEMu8_AVX512=5027, + XED_IFORM_VPSADBW_XMMu16_XMMu8_XMMu8_AVX512=5028, + XED_IFORM_VPSADBW_YMMqq_YMMqq_MEMqq=5029, + XED_IFORM_VPSADBW_YMMqq_YMMqq_YMMqq=5030, + XED_IFORM_VPSADBW_YMMu16_YMMu8_MEMu8_AVX512=5031, + XED_IFORM_VPSADBW_YMMu16_YMMu8_YMMu8_AVX512=5032, + XED_IFORM_VPSADBW_ZMMu16_ZMMu8_MEMu8_AVX512=5033, + XED_IFORM_VPSADBW_ZMMu16_ZMMu8_ZMMu8_AVX512=5034, + XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_XMMu32_AVX512_VL128=5035, + XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_YMMu32_AVX512_VL256=5036, + XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_ZMMu32_AVX512_VL512=5037, + XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128=5038, + XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256=5039, + XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512=5040, + XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL128=5041, + XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL256=5042, + XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_YMMu32_AVX512_VL512=5043, + XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128=5044, + XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256=5045, + XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512=5046, + XED_IFORM_VPSHAB_XMMdq_MEMdq_XMMdq=5047, + XED_IFORM_VPSHAB_XMMdq_XMMdq_MEMdq=5048, + XED_IFORM_VPSHAB_XMMdq_XMMdq_XMMdq=5049, + XED_IFORM_VPSHAD_XMMdq_MEMdq_XMMdq=5050, + XED_IFORM_VPSHAD_XMMdq_XMMdq_MEMdq=5051, + XED_IFORM_VPSHAD_XMMdq_XMMdq_XMMdq=5052, + XED_IFORM_VPSHAQ_XMMdq_MEMdq_XMMdq=5053, + XED_IFORM_VPSHAQ_XMMdq_XMMdq_MEMdq=5054, + XED_IFORM_VPSHAQ_XMMdq_XMMdq_XMMdq=5055, + XED_IFORM_VPSHAW_XMMdq_MEMdq_XMMdq=5056, + XED_IFORM_VPSHAW_XMMdq_XMMdq_MEMdq=5057, + XED_IFORM_VPSHAW_XMMdq_XMMdq_XMMdq=5058, + XED_IFORM_VPSHLB_XMMdq_MEMdq_XMMdq=5059, + XED_IFORM_VPSHLB_XMMdq_XMMdq_MEMdq=5060, + XED_IFORM_VPSHLB_XMMdq_XMMdq_XMMdq=5061, + XED_IFORM_VPSHLD_XMMdq_MEMdq_XMMdq=5062, + XED_IFORM_VPSHLD_XMMdq_XMMdq_MEMdq=5063, + XED_IFORM_VPSHLD_XMMdq_XMMdq_XMMdq=5064, + XED_IFORM_VPSHLQ_XMMdq_MEMdq_XMMdq=5065, + XED_IFORM_VPSHLQ_XMMdq_XMMdq_MEMdq=5066, + XED_IFORM_VPSHLQ_XMMdq_XMMdq_XMMdq=5067, + XED_IFORM_VPSHLW_XMMdq_MEMdq_XMMdq=5068, + XED_IFORM_VPSHLW_XMMdq_XMMdq_MEMdq=5069, + XED_IFORM_VPSHLW_XMMdq_XMMdq_XMMdq=5070, + XED_IFORM_VPSHUFB_XMMdq_XMMdq_MEMdq=5071, + XED_IFORM_VPSHUFB_XMMdq_XMMdq_XMMdq=5072, + XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5073, + XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5074, + XED_IFORM_VPSHUFB_YMMqq_YMMqq_MEMqq=5075, + XED_IFORM_VPSHUFB_YMMqq_YMMqq_YMMqq=5076, + XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5077, + XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5078, + XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5079, + XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5080, + XED_IFORM_VPSHUFD_XMMdq_MEMdq_IMMb=5081, + XED_IFORM_VPSHUFD_XMMdq_XMMdq_IMMb=5082, + XED_IFORM_VPSHUFD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5083, + XED_IFORM_VPSHUFD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5084, + XED_IFORM_VPSHUFD_YMMqq_MEMqq_IMMb=5085, + XED_IFORM_VPSHUFD_YMMqq_YMMqq_IMMb=5086, + XED_IFORM_VPSHUFD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5087, + XED_IFORM_VPSHUFD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5088, + XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5089, + XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5090, + XED_IFORM_VPSHUFHW_XMMdq_MEMdq_IMMb=5091, + XED_IFORM_VPSHUFHW_XMMdq_XMMdq_IMMb=5092, + XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5093, + XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5094, + XED_IFORM_VPSHUFHW_YMMqq_MEMqq_IMMb=5095, + XED_IFORM_VPSHUFHW_YMMqq_YMMqq_IMMb=5096, + XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5097, + XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5098, + XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5099, + XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5100, + XED_IFORM_VPSHUFLW_XMMdq_MEMdq_IMMb=5101, + XED_IFORM_VPSHUFLW_XMMdq_XMMdq_IMMb=5102, + XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5103, + XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5104, + XED_IFORM_VPSHUFLW_YMMqq_MEMqq_IMMb=5105, + XED_IFORM_VPSHUFLW_YMMqq_YMMqq_IMMb=5106, + XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5107, + XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5108, + XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5109, + XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5110, + XED_IFORM_VPSIGNB_XMMdq_XMMdq_MEMdq=5111, + XED_IFORM_VPSIGNB_XMMdq_XMMdq_XMMdq=5112, + XED_IFORM_VPSIGNB_YMMqq_YMMqq_MEMqq=5113, + XED_IFORM_VPSIGNB_YMMqq_YMMqq_YMMqq=5114, + XED_IFORM_VPSIGND_XMMdq_XMMdq_MEMdq=5115, + XED_IFORM_VPSIGND_XMMdq_XMMdq_XMMdq=5116, + XED_IFORM_VPSIGND_YMMqq_YMMqq_MEMqq=5117, + XED_IFORM_VPSIGND_YMMqq_YMMqq_YMMqq=5118, + XED_IFORM_VPSIGNW_XMMdq_XMMdq_MEMdq=5119, + XED_IFORM_VPSIGNW_XMMdq_XMMdq_XMMdq=5120, + XED_IFORM_VPSIGNW_YMMqq_YMMqq_MEMqq=5121, + XED_IFORM_VPSIGNW_YMMqq_YMMqq_YMMqq=5122, + XED_IFORM_VPSLLD_XMMdq_XMMdq_IMMb=5123, + XED_IFORM_VPSLLD_XMMdq_XMMdq_MEMdq=5124, + XED_IFORM_VPSLLD_XMMdq_XMMdq_XMMdq=5125, + XED_IFORM_VPSLLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5126, + XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5127, + XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5128, + XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5129, + XED_IFORM_VPSLLD_YMMqq_YMMqq_IMMb=5130, + XED_IFORM_VPSLLD_YMMqq_YMMqq_MEMdq=5131, + XED_IFORM_VPSLLD_YMMqq_YMMqq_XMMq=5132, + XED_IFORM_VPSLLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5133, + XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5134, + XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5135, + XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=5136, + XED_IFORM_VPSLLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5137, + XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5138, + XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5139, + XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=5140, + XED_IFORM_VPSLLDQ_XMMdq_XMMdq_IMMb=5141, + XED_IFORM_VPSLLDQ_XMMu8_MEMu8_IMM8_AVX512=5142, + XED_IFORM_VPSLLDQ_XMMu8_XMMu8_IMM8_AVX512=5143, + XED_IFORM_VPSLLDQ_YMMqq_YMMqq_IMMb=5144, + XED_IFORM_VPSLLDQ_YMMu8_MEMu8_IMM8_AVX512=5145, + XED_IFORM_VPSLLDQ_YMMu8_YMMu8_IMM8_AVX512=5146, + XED_IFORM_VPSLLDQ_ZMMu8_MEMu8_IMM8_AVX512=5147, + XED_IFORM_VPSLLDQ_ZMMu8_ZMMu8_IMM8_AVX512=5148, + XED_IFORM_VPSLLQ_XMMdq_XMMdq_IMMb=5149, + XED_IFORM_VPSLLQ_XMMdq_XMMdq_MEMdq=5150, + XED_IFORM_VPSLLQ_XMMdq_XMMdq_XMMdq=5151, + XED_IFORM_VPSLLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5152, + XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5153, + XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5154, + XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5155, + XED_IFORM_VPSLLQ_YMMqq_YMMqq_IMMb=5156, + XED_IFORM_VPSLLQ_YMMqq_YMMqq_MEMdq=5157, + XED_IFORM_VPSLLQ_YMMqq_YMMqq_XMMq=5158, + XED_IFORM_VPSLLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5159, + XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5160, + XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5161, + XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=5162, + XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5163, + XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5164, + XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5165, + XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=5166, + XED_IFORM_VPSLLVD_XMMdq_XMMdq_MEMdq=5167, + XED_IFORM_VPSLLVD_XMMdq_XMMdq_XMMdq=5168, + XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5169, + XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5170, + XED_IFORM_VPSLLVD_YMMqq_YMMqq_MEMqq=5171, + XED_IFORM_VPSLLVD_YMMqq_YMMqq_YMMqq=5172, + XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5173, + XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5174, + XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5175, + XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5176, + XED_IFORM_VPSLLVQ_XMMdq_XMMdq_MEMdq=5177, + XED_IFORM_VPSLLVQ_XMMdq_XMMdq_XMMdq=5178, + XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5179, + XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5180, + XED_IFORM_VPSLLVQ_YMMqq_YMMqq_MEMqq=5181, + XED_IFORM_VPSLLVQ_YMMqq_YMMqq_YMMqq=5182, + XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5183, + XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5184, + XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5185, + XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5186, + XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5187, + XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5188, + XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5189, + XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5190, + XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5191, + XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5192, + XED_IFORM_VPSLLW_XMMdq_XMMdq_IMMb=5193, + XED_IFORM_VPSLLW_XMMdq_XMMdq_MEMdq=5194, + XED_IFORM_VPSLLW_XMMdq_XMMdq_XMMdq=5195, + XED_IFORM_VPSLLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5196, + XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5197, + XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5198, + XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5199, + XED_IFORM_VPSLLW_YMMqq_YMMqq_IMMb=5200, + XED_IFORM_VPSLLW_YMMqq_YMMqq_MEMdq=5201, + XED_IFORM_VPSLLW_YMMqq_YMMqq_XMMq=5202, + XED_IFORM_VPSLLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5203, + XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5204, + XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5205, + XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=5206, + XED_IFORM_VPSLLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5207, + XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5208, + XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5209, + XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=5210, + XED_IFORM_VPSRAD_XMMdq_XMMdq_IMMb=5211, + XED_IFORM_VPSRAD_XMMdq_XMMdq_MEMdq=5212, + XED_IFORM_VPSRAD_XMMdq_XMMdq_XMMdq=5213, + XED_IFORM_VPSRAD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5214, + XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5215, + XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5216, + XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5217, + XED_IFORM_VPSRAD_YMMqq_YMMqq_IMMb=5218, + XED_IFORM_VPSRAD_YMMqq_YMMqq_MEMdq=5219, + XED_IFORM_VPSRAD_YMMqq_YMMqq_XMMq=5220, + XED_IFORM_VPSRAD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5221, + XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5222, + XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5223, + XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=5224, + XED_IFORM_VPSRAD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5225, + XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5226, + XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5227, + XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=5228, + XED_IFORM_VPSRAQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5229, + XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5230, + XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5231, + XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5232, + XED_IFORM_VPSRAQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5233, + XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5234, + XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5235, + XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=5236, + XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5237, + XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5238, + XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5239, + XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=5240, + XED_IFORM_VPSRAVD_XMMdq_XMMdq_MEMdq=5241, + XED_IFORM_VPSRAVD_XMMdq_XMMdq_XMMdq=5242, + XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5243, + XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5244, + XED_IFORM_VPSRAVD_YMMqq_YMMqq_MEMqq=5245, + XED_IFORM_VPSRAVD_YMMqq_YMMqq_YMMqq=5246, + XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5247, + XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5248, + XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5249, + XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5250, + XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5251, + XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5252, + XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5253, + XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5254, + XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5255, + XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5256, + XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5257, + XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5258, + XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5259, + XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5260, + XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5261, + XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5262, + XED_IFORM_VPSRAW_XMMdq_XMMdq_IMMb=5263, + XED_IFORM_VPSRAW_XMMdq_XMMdq_MEMdq=5264, + XED_IFORM_VPSRAW_XMMdq_XMMdq_XMMdq=5265, + XED_IFORM_VPSRAW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5266, + XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5267, + XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5268, + XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5269, + XED_IFORM_VPSRAW_YMMqq_YMMqq_IMMb=5270, + XED_IFORM_VPSRAW_YMMqq_YMMqq_MEMdq=5271, + XED_IFORM_VPSRAW_YMMqq_YMMqq_XMMq=5272, + XED_IFORM_VPSRAW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5273, + XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5274, + XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5275, + XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=5276, + XED_IFORM_VPSRAW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5277, + XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5278, + XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5279, + XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=5280, + XED_IFORM_VPSRLD_XMMdq_XMMdq_IMMb=5281, + XED_IFORM_VPSRLD_XMMdq_XMMdq_MEMdq=5282, + XED_IFORM_VPSRLD_XMMdq_XMMdq_XMMdq=5283, + XED_IFORM_VPSRLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5284, + XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5285, + XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5286, + XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5287, + XED_IFORM_VPSRLD_YMMqq_YMMqq_IMMb=5288, + XED_IFORM_VPSRLD_YMMqq_YMMqq_MEMdq=5289, + XED_IFORM_VPSRLD_YMMqq_YMMqq_XMMq=5290, + XED_IFORM_VPSRLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5291, + XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5292, + XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5293, + XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=5294, + XED_IFORM_VPSRLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5295, + XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5296, + XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5297, + XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=5298, + XED_IFORM_VPSRLDQ_XMMdq_XMMdq_IMMb=5299, + XED_IFORM_VPSRLDQ_XMMu8_MEMu8_IMM8_AVX512=5300, + XED_IFORM_VPSRLDQ_XMMu8_XMMu8_IMM8_AVX512=5301, + XED_IFORM_VPSRLDQ_YMMqq_YMMqq_IMMb=5302, + XED_IFORM_VPSRLDQ_YMMu8_MEMu8_IMM8_AVX512=5303, + XED_IFORM_VPSRLDQ_YMMu8_YMMu8_IMM8_AVX512=5304, + XED_IFORM_VPSRLDQ_ZMMu8_MEMu8_IMM8_AVX512=5305, + XED_IFORM_VPSRLDQ_ZMMu8_ZMMu8_IMM8_AVX512=5306, + XED_IFORM_VPSRLQ_XMMdq_XMMdq_IMMb=5307, + XED_IFORM_VPSRLQ_XMMdq_XMMdq_MEMdq=5308, + XED_IFORM_VPSRLQ_XMMdq_XMMdq_XMMdq=5309, + XED_IFORM_VPSRLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5310, + XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5311, + XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5312, + XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5313, + XED_IFORM_VPSRLQ_YMMqq_YMMqq_IMMb=5314, + XED_IFORM_VPSRLQ_YMMqq_YMMqq_MEMdq=5315, + XED_IFORM_VPSRLQ_YMMqq_YMMqq_XMMq=5316, + XED_IFORM_VPSRLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5317, + XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5318, + XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5319, + XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=5320, + XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5321, + XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5322, + XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5323, + XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=5324, + XED_IFORM_VPSRLVD_XMMdq_XMMdq_MEMdq=5325, + XED_IFORM_VPSRLVD_XMMdq_XMMdq_XMMdq=5326, + XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5327, + XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5328, + XED_IFORM_VPSRLVD_YMMqq_YMMqq_MEMqq=5329, + XED_IFORM_VPSRLVD_YMMqq_YMMqq_YMMqq=5330, + XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5331, + XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5332, + XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5333, + XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5334, + XED_IFORM_VPSRLVQ_XMMdq_XMMdq_MEMdq=5335, + XED_IFORM_VPSRLVQ_XMMdq_XMMdq_XMMdq=5336, + XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5337, + XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5338, + XED_IFORM_VPSRLVQ_YMMqq_YMMqq_MEMqq=5339, + XED_IFORM_VPSRLVQ_YMMqq_YMMqq_YMMqq=5340, + XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5341, + XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5342, + XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5343, + XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5344, + XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5345, + XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5346, + XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5347, + XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5348, + XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5349, + XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5350, + XED_IFORM_VPSRLW_XMMdq_XMMdq_IMMb=5351, + XED_IFORM_VPSRLW_XMMdq_XMMdq_MEMdq=5352, + XED_IFORM_VPSRLW_XMMdq_XMMdq_XMMdq=5353, + XED_IFORM_VPSRLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5354, + XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5355, + XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5356, + XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5357, + XED_IFORM_VPSRLW_YMMqq_YMMqq_IMMb=5358, + XED_IFORM_VPSRLW_YMMqq_YMMqq_MEMdq=5359, + XED_IFORM_VPSRLW_YMMqq_YMMqq_XMMq=5360, + XED_IFORM_VPSRLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5361, + XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5362, + XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5363, + XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=5364, + XED_IFORM_VPSRLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5365, + XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5366, + XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5367, + XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=5368, + XED_IFORM_VPSUBB_XMMdq_XMMdq_MEMdq=5369, + XED_IFORM_VPSUBB_XMMdq_XMMdq_XMMdq=5370, + XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5371, + XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5372, + XED_IFORM_VPSUBB_YMMqq_YMMqq_MEMqq=5373, + XED_IFORM_VPSUBB_YMMqq_YMMqq_YMMqq=5374, + XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5375, + XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5376, + XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5377, + XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5378, + XED_IFORM_VPSUBD_XMMdq_XMMdq_MEMdq=5379, + XED_IFORM_VPSUBD_XMMdq_XMMdq_XMMdq=5380, + XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5381, + XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5382, + XED_IFORM_VPSUBD_YMMqq_YMMqq_MEMqq=5383, + XED_IFORM_VPSUBD_YMMqq_YMMqq_YMMqq=5384, + XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5385, + XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5386, + XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5387, + XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5388, + XED_IFORM_VPSUBQ_XMMdq_XMMdq_MEMdq=5389, + XED_IFORM_VPSUBQ_XMMdq_XMMdq_XMMdq=5390, + XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5391, + XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5392, + XED_IFORM_VPSUBQ_YMMqq_YMMqq_MEMqq=5393, + XED_IFORM_VPSUBQ_YMMqq_YMMqq_YMMqq=5394, + XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5395, + XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5396, + XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5397, + XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5398, + XED_IFORM_VPSUBSB_XMMdq_XMMdq_MEMdq=5399, + XED_IFORM_VPSUBSB_XMMdq_XMMdq_XMMdq=5400, + XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=5401, + XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=5402, + XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=5403, + XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=5404, + XED_IFORM_VPSUBSB_YMMqq_YMMqq_MEMqq=5405, + XED_IFORM_VPSUBSB_YMMqq_YMMqq_YMMqq=5406, + XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=5407, + XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=5408, + XED_IFORM_VPSUBSW_XMMdq_XMMdq_MEMdq=5409, + XED_IFORM_VPSUBSW_XMMdq_XMMdq_XMMdq=5410, + XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=5411, + XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=5412, + XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=5413, + XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=5414, + XED_IFORM_VPSUBSW_YMMqq_YMMqq_MEMqq=5415, + XED_IFORM_VPSUBSW_YMMqq_YMMqq_YMMqq=5416, + XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=5417, + XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=5418, + XED_IFORM_VPSUBUSB_XMMdq_XMMdq_MEMdq=5419, + XED_IFORM_VPSUBUSB_XMMdq_XMMdq_XMMdq=5420, + XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5421, + XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5422, + XED_IFORM_VPSUBUSB_YMMqq_YMMqq_MEMqq=5423, + XED_IFORM_VPSUBUSB_YMMqq_YMMqq_YMMqq=5424, + XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5425, + XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5426, + XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5427, + XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5428, + XED_IFORM_VPSUBUSW_XMMdq_XMMdq_MEMdq=5429, + XED_IFORM_VPSUBUSW_XMMdq_XMMdq_XMMdq=5430, + XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5431, + XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5432, + XED_IFORM_VPSUBUSW_YMMqq_YMMqq_MEMqq=5433, + XED_IFORM_VPSUBUSW_YMMqq_YMMqq_YMMqq=5434, + XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5435, + XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5436, + XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5437, + XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5438, + XED_IFORM_VPSUBW_XMMdq_XMMdq_MEMdq=5439, + XED_IFORM_VPSUBW_XMMdq_XMMdq_XMMdq=5440, + XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5441, + XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5442, + XED_IFORM_VPSUBW_YMMqq_YMMqq_MEMqq=5443, + XED_IFORM_VPSUBW_YMMqq_YMMqq_YMMqq=5444, + XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5445, + XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5446, + XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5447, + XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5448, + XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=5449, + XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=5450, + XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=5451, + XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=5452, + XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=5453, + XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=5454, + XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=5455, + XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=5456, + XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=5457, + XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=5458, + XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=5459, + XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=5460, + XED_IFORM_VPTEST_XMMdq_MEMdq=5461, + XED_IFORM_VPTEST_XMMdq_XMMdq=5462, + XED_IFORM_VPTEST_YMMqq_MEMqq=5463, + XED_IFORM_VPTEST_YMMqq_YMMqq=5464, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=5465, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=5466, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=5467, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=5468, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=5469, + XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=5470, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=5471, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=5472, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=5473, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=5474, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=5475, + XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=5476, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=5477, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=5478, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=5479, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=5480, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=5481, + XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=5482, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=5483, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=5484, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=5485, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=5486, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=5487, + XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=5488, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=5489, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=5490, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=5491, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=5492, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=5493, + XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=5494, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=5495, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=5496, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=5497, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=5498, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=5499, + XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=5500, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=5501, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=5502, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=5503, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=5504, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=5505, + XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=5506, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=5507, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=5508, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=5509, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=5510, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=5511, + XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=5512, + XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_MEMdq=5513, + XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_XMMdq=5514, + XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5515, + XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5516, + XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_MEMqq=5517, + XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_YMMqq=5518, + XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5519, + XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5520, + XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5521, + XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5522, + XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_MEMdq=5523, + XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_XMMdq=5524, + XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5525, + XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5526, + XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_MEMqq=5527, + XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_YMMqq=5528, + XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5529, + XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5530, + XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5531, + XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5532, + XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_MEMdq=5533, + XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_XMMdq=5534, + XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5535, + XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5536, + XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_MEMqq=5537, + XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_YMMqq=5538, + XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5539, + XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5540, + XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5541, + XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5542, + XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_MEMdq=5543, + XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_XMMdq=5544, + XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5545, + XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5546, + XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_MEMqq=5547, + XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_YMMqq=5548, + XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5549, + XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5550, + XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5551, + XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5552, + XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_MEMdq=5553, + XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_XMMdq=5554, + XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5555, + XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5556, + XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_MEMqq=5557, + XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_YMMqq=5558, + XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5559, + XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5560, + XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5561, + XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5562, + XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_MEMdq=5563, + XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_XMMdq=5564, + XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5565, + XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5566, + XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_MEMqq=5567, + XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_YMMqq=5568, + XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5569, + XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5570, + XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5571, + XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5572, + XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_MEMdq=5573, + XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_XMMdq=5574, + XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5575, + XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5576, + XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_MEMqq=5577, + XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_YMMqq=5578, + XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5579, + XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5580, + XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5581, + XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5582, + XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_MEMdq=5583, + XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_XMMdq=5584, + XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5585, + XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5586, + XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_MEMqq=5587, + XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_YMMqq=5588, + XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5589, + XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5590, + XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5591, + XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5592, + XED_IFORM_VPXOR_XMMdq_XMMdq_MEMdq=5593, + XED_IFORM_VPXOR_XMMdq_XMMdq_XMMdq=5594, + XED_IFORM_VPXOR_YMMqq_YMMqq_MEMqq=5595, + XED_IFORM_VPXOR_YMMqq_YMMqq_YMMqq=5596, + XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5597, + XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5598, + XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5599, + XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5600, + XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5601, + XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5602, + XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5603, + XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5604, + XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5605, + XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5606, + XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5607, + XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5608, + XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=5609, + XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=5610, + XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=5611, + XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=5612, + XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=5613, + XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=5614, + XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=5615, + XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=5616, + XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=5617, + XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=5618, + XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=5619, + XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=5620, + XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=5621, + XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=5622, + XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=5623, + XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=5624, + XED_IFORM_VRCP14PD_XMMf64_MASKmskw_MEMf64_AVX512=5625, + XED_IFORM_VRCP14PD_XMMf64_MASKmskw_XMMf64_AVX512=5626, + XED_IFORM_VRCP14PD_YMMf64_MASKmskw_MEMf64_AVX512=5627, + XED_IFORM_VRCP14PD_YMMf64_MASKmskw_YMMf64_AVX512=5628, + XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_MEMf64_AVX512=5629, + XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_ZMMf64_AVX512=5630, + XED_IFORM_VRCP14PS_XMMf32_MASKmskw_MEMf32_AVX512=5631, + XED_IFORM_VRCP14PS_XMMf32_MASKmskw_XMMf32_AVX512=5632, + XED_IFORM_VRCP14PS_YMMf32_MASKmskw_MEMf32_AVX512=5633, + XED_IFORM_VRCP14PS_YMMf32_MASKmskw_YMMf32_AVX512=5634, + XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_MEMf32_AVX512=5635, + XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_ZMMf32_AVX512=5636, + XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5637, + XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5638, + XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5639, + XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5640, + XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=5641, + XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=5642, + XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=5643, + XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=5644, + XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER=5645, + XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER=5646, + XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER=5647, + XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER=5648, + XED_IFORM_VRCPPS_XMMdq_MEMdq=5649, + XED_IFORM_VRCPPS_XMMdq_XMMdq=5650, + XED_IFORM_VRCPPS_YMMqq_MEMqq=5651, + XED_IFORM_VRCPPS_YMMqq_YMMqq=5652, + XED_IFORM_VRCPSS_XMMdq_XMMdq_MEMd=5653, + XED_IFORM_VRCPSS_XMMdq_XMMdq_XMMd=5654, + XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=5655, + XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=5656, + XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=5657, + XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=5658, + XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=5659, + XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=5660, + XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=5661, + XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=5662, + XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=5663, + XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=5664, + XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=5665, + XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=5666, + XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=5667, + XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=5668, + XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=5669, + XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=5670, + XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=5671, + XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=5672, + XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=5673, + XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=5674, + XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=5675, + XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=5676, + XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=5677, + XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=5678, + XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=5679, + XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=5680, + XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=5681, + XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=5682, + XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=5683, + XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=5684, + XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=5685, + XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=5686, + XED_IFORM_VROUNDPD_XMMdq_MEMdq_IMMb=5687, + XED_IFORM_VROUNDPD_XMMdq_XMMdq_IMMb=5688, + XED_IFORM_VROUNDPD_YMMqq_MEMqq_IMMb=5689, + XED_IFORM_VROUNDPD_YMMqq_YMMqq_IMMb=5690, + XED_IFORM_VROUNDPS_XMMdq_MEMdq_IMMb=5691, + XED_IFORM_VROUNDPS_XMMdq_XMMdq_IMMb=5692, + XED_IFORM_VROUNDPS_YMMqq_MEMqq_IMMb=5693, + XED_IFORM_VROUNDPS_YMMqq_YMMqq_IMMb=5694, + XED_IFORM_VROUNDSD_XMMdq_XMMdq_MEMq_IMMb=5695, + XED_IFORM_VROUNDSD_XMMdq_XMMdq_XMMq_IMMb=5696, + XED_IFORM_VROUNDSS_XMMdq_XMMdq_MEMd_IMMb=5697, + XED_IFORM_VROUNDSS_XMMdq_XMMdq_XMMd_IMMb=5698, + XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_MEMf64_AVX512=5699, + XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_XMMf64_AVX512=5700, + XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_MEMf64_AVX512=5701, + XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_YMMf64_AVX512=5702, + XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_MEMf64_AVX512=5703, + XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_ZMMf64_AVX512=5704, + XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_MEMf32_AVX512=5705, + XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_XMMf32_AVX512=5706, + XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_MEMf32_AVX512=5707, + XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_YMMf32_AVX512=5708, + XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_MEMf32_AVX512=5709, + XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_ZMMf32_AVX512=5710, + XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5711, + XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5712, + XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5713, + XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5714, + XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=5715, + XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=5716, + XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=5717, + XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=5718, + XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER=5719, + XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER=5720, + XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER=5721, + XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER=5722, + XED_IFORM_VRSQRTPS_XMMdq_MEMdq=5723, + XED_IFORM_VRSQRTPS_XMMdq_XMMdq=5724, + XED_IFORM_VRSQRTPS_YMMqq_MEMqq=5725, + XED_IFORM_VRSQRTPS_YMMqq_YMMqq=5726, + XED_IFORM_VRSQRTSS_XMMdq_XMMdq_MEMd=5727, + XED_IFORM_VRSQRTSS_XMMdq_XMMdq_XMMd=5728, + XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5729, + XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5730, + XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=5731, + XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=5732, + XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=5733, + XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=5734, + XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5735, + XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5736, + XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=5737, + XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=5738, + XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=5739, + XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=5740, + XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5741, + XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5742, + XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5743, + XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5744, + XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128=5745, + XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256=5746, + XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512=5747, + XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128=5748, + XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_YMMf32_AVX512_VL256=5749, + XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_ZMMf32_AVX512_VL512=5750, + XED_IFORM_VSCATTERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512=5751, + XED_IFORM_VSCATTERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512=5752, + XED_IFORM_VSCATTERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512=5753, + XED_IFORM_VSCATTERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512=5754, + XED_IFORM_VSCATTERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512=5755, + XED_IFORM_VSCATTERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512=5756, + XED_IFORM_VSCATTERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512=5757, + XED_IFORM_VSCATTERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512=5758, + XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128=5759, + XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256=5760, + XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512=5761, + XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128=5762, + XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL256=5763, + XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_YMMf32_AVX512_VL512=5764, + XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=5765, + XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=5766, + XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=5767, + XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=5768, + XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=5769, + XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=5770, + XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=5771, + XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=5772, + XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=5773, + XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=5774, + XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=5775, + XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=5776, + XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=5777, + XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=5778, + XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=5779, + XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=5780, + XED_IFORM_VSHUFPD_XMMdq_XMMdq_MEMdq_IMMb=5781, + XED_IFORM_VSHUFPD_XMMdq_XMMdq_XMMdq_IMMb=5782, + XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=5783, + XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=5784, + XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=5785, + XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=5786, + XED_IFORM_VSHUFPD_YMMqq_YMMqq_MEMqq_IMMb=5787, + XED_IFORM_VSHUFPD_YMMqq_YMMqq_YMMqq_IMMb=5788, + XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=5789, + XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=5790, + XED_IFORM_VSHUFPS_XMMdq_XMMdq_MEMdq_IMMb=5791, + XED_IFORM_VSHUFPS_XMMdq_XMMdq_XMMdq_IMMb=5792, + XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=5793, + XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=5794, + XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=5795, + XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=5796, + XED_IFORM_VSHUFPS_YMMqq_YMMqq_MEMqq_IMMb=5797, + XED_IFORM_VSHUFPS_YMMqq_YMMqq_YMMqq_IMMb=5798, + XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=5799, + XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=5800, + XED_IFORM_VSQRTPD_XMMdq_MEMdq=5801, + XED_IFORM_VSQRTPD_XMMdq_XMMdq=5802, + XED_IFORM_VSQRTPD_XMMf64_MASKmskw_MEMf64_AVX512=5803, + XED_IFORM_VSQRTPD_XMMf64_MASKmskw_XMMf64_AVX512=5804, + XED_IFORM_VSQRTPD_YMMf64_MASKmskw_MEMf64_AVX512=5805, + XED_IFORM_VSQRTPD_YMMf64_MASKmskw_YMMf64_AVX512=5806, + XED_IFORM_VSQRTPD_YMMqq_MEMqq=5807, + XED_IFORM_VSQRTPD_YMMqq_YMMqq=5808, + XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_MEMf64_AVX512=5809, + XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_ZMMf64_AVX512=5810, + XED_IFORM_VSQRTPS_XMMdq_MEMdq=5811, + XED_IFORM_VSQRTPS_XMMdq_XMMdq=5812, + XED_IFORM_VSQRTPS_XMMf32_MASKmskw_MEMf32_AVX512=5813, + XED_IFORM_VSQRTPS_XMMf32_MASKmskw_XMMf32_AVX512=5814, + XED_IFORM_VSQRTPS_YMMf32_MASKmskw_MEMf32_AVX512=5815, + XED_IFORM_VSQRTPS_YMMf32_MASKmskw_YMMf32_AVX512=5816, + XED_IFORM_VSQRTPS_YMMqq_MEMqq=5817, + XED_IFORM_VSQRTPS_YMMqq_YMMqq=5818, + XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_MEMf32_AVX512=5819, + XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_ZMMf32_AVX512=5820, + XED_IFORM_VSQRTSD_XMMdq_XMMdq_MEMq=5821, + XED_IFORM_VSQRTSD_XMMdq_XMMdq_XMMq=5822, + XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5823, + XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5824, + XED_IFORM_VSQRTSS_XMMdq_XMMdq_MEMd=5825, + XED_IFORM_VSQRTSS_XMMdq_XMMdq_XMMd=5826, + XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5827, + XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5828, + XED_IFORM_VSTMXCSR_MEMd=5829, + XED_IFORM_VSUBPD_XMMdq_XMMdq_MEMdq=5830, + XED_IFORM_VSUBPD_XMMdq_XMMdq_XMMdq=5831, + XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5832, + XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5833, + XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=5834, + XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=5835, + XED_IFORM_VSUBPD_YMMqq_YMMqq_MEMqq=5836, + XED_IFORM_VSUBPD_YMMqq_YMMqq_YMMqq=5837, + XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=5838, + XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=5839, + XED_IFORM_VSUBPS_XMMdq_XMMdq_MEMdq=5840, + XED_IFORM_VSUBPS_XMMdq_XMMdq_XMMdq=5841, + XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5842, + XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5843, + XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=5844, + XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=5845, + XED_IFORM_VSUBPS_YMMqq_YMMqq_MEMqq=5846, + XED_IFORM_VSUBPS_YMMqq_YMMqq_YMMqq=5847, + XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=5848, + XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=5849, + XED_IFORM_VSUBSD_XMMdq_XMMdq_MEMq=5850, + XED_IFORM_VSUBSD_XMMdq_XMMdq_XMMq=5851, + XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5852, + XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5853, + XED_IFORM_VSUBSS_XMMdq_XMMdq_MEMd=5854, + XED_IFORM_VSUBSS_XMMdq_XMMdq_XMMd=5855, + XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5856, + XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5857, + XED_IFORM_VTESTPD_XMMdq_MEMdq=5858, + XED_IFORM_VTESTPD_XMMdq_XMMdq=5859, + XED_IFORM_VTESTPD_YMMqq_MEMqq=5860, + XED_IFORM_VTESTPD_YMMqq_YMMqq=5861, + XED_IFORM_VTESTPS_XMMdq_MEMdq=5862, + XED_IFORM_VTESTPS_XMMdq_XMMdq=5863, + XED_IFORM_VTESTPS_YMMqq_MEMqq=5864, + XED_IFORM_VTESTPS_YMMqq_YMMqq=5865, + XED_IFORM_VUCOMISD_XMMdq_MEMq=5866, + XED_IFORM_VUCOMISD_XMMdq_XMMq=5867, + XED_IFORM_VUCOMISD_XMMf64_MEMf64_AVX512=5868, + XED_IFORM_VUCOMISD_XMMf64_XMMf64_AVX512=5869, + XED_IFORM_VUCOMISS_XMMdq_MEMd=5870, + XED_IFORM_VUCOMISS_XMMdq_XMMd=5871, + XED_IFORM_VUCOMISS_XMMf32_MEMf32_AVX512=5872, + XED_IFORM_VUCOMISS_XMMf32_XMMf32_AVX512=5873, + XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_MEMdq=5874, + XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_XMMdq=5875, + XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5876, + XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5877, + XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=5878, + XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=5879, + XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_MEMqq=5880, + XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_YMMqq=5881, + XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=5882, + XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=5883, + XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_MEMdq=5884, + XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_XMMdq=5885, + XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5886, + XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5887, + XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=5888, + XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=5889, + XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_MEMqq=5890, + XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_YMMqq=5891, + XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=5892, + XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=5893, + XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_MEMdq=5894, + XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_XMMdq=5895, + XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5896, + XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5897, + XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=5898, + XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=5899, + XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_MEMqq=5900, + XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_YMMqq=5901, + XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=5902, + XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=5903, + XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_MEMdq=5904, + XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_XMMdq=5905, + XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5906, + XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5907, + XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=5908, + XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=5909, + XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_MEMqq=5910, + XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_YMMqq=5911, + XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=5912, + XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=5913, + XED_IFORM_VXORPD_XMMdq_XMMdq_MEMdq=5914, + XED_IFORM_VXORPD_XMMdq_XMMdq_XMMdq=5915, + XED_IFORM_VXORPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=5916, + XED_IFORM_VXORPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=5917, + XED_IFORM_VXORPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=5918, + XED_IFORM_VXORPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=5919, + XED_IFORM_VXORPD_YMMqq_YMMqq_MEMqq=5920, + XED_IFORM_VXORPD_YMMqq_YMMqq_YMMqq=5921, + XED_IFORM_VXORPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=5922, + XED_IFORM_VXORPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=5923, + XED_IFORM_VXORPS_XMMdq_XMMdq_MEMdq=5924, + XED_IFORM_VXORPS_XMMdq_XMMdq_XMMdq=5925, + XED_IFORM_VXORPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=5926, + XED_IFORM_VXORPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=5927, + XED_IFORM_VXORPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=5928, + XED_IFORM_VXORPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=5929, + XED_IFORM_VXORPS_YMMqq_YMMqq_MEMqq=5930, + XED_IFORM_VXORPS_YMMqq_YMMqq_YMMqq=5931, + XED_IFORM_VXORPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=5932, + XED_IFORM_VXORPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=5933, + XED_IFORM_VZEROALL=5934, + XED_IFORM_VZEROUPPER=5935, + XED_IFORM_WBINVD=5936, + XED_IFORM_WRFSBASE_GPRy=5937, + XED_IFORM_WRGSBASE_GPRy=5938, + XED_IFORM_WRMSR=5939, + XED_IFORM_XABORT_IMMb=5940, + XED_IFORM_XADD_GPR8_GPR8=5941, + XED_IFORM_XADD_GPRv_GPRv=5942, + XED_IFORM_XADD_MEMb_GPR8=5943, + XED_IFORM_XADD_MEMv_GPRv=5944, + XED_IFORM_XADD_LOCK_MEMb_GPR8=5945, + XED_IFORM_XADD_LOCK_MEMv_GPRv=5946, + XED_IFORM_XBEGIN_RELBRz=5947, + XED_IFORM_XCHG_GPR8_GPR8=5948, + XED_IFORM_XCHG_GPRv_GPRv=5949, + XED_IFORM_XCHG_GPRv_OrAX=5950, + XED_IFORM_XCHG_MEMb_GPR8=5951, + XED_IFORM_XCHG_MEMv_GPRv=5952, + XED_IFORM_XEND=5953, + XED_IFORM_XGETBV=5954, + XED_IFORM_XLAT=5955, + XED_IFORM_XOR_AL_IMMb=5956, + XED_IFORM_XOR_GPR8_GPR8_30=5957, + XED_IFORM_XOR_GPR8_GPR8_32=5958, + XED_IFORM_XOR_GPR8_IMMb_80r6=5959, + XED_IFORM_XOR_GPR8_IMMb_82r6=5960, + XED_IFORM_XOR_GPR8_MEMb=5961, + XED_IFORM_XOR_GPRv_GPRv_31=5962, + XED_IFORM_XOR_GPRv_GPRv_33=5963, + XED_IFORM_XOR_GPRv_IMMb=5964, + XED_IFORM_XOR_GPRv_IMMz=5965, + XED_IFORM_XOR_GPRv_MEMv=5966, + XED_IFORM_XOR_MEMb_GPR8=5967, + XED_IFORM_XOR_MEMb_IMMb_80r6=5968, + XED_IFORM_XOR_MEMb_IMMb_82r6=5969, + XED_IFORM_XOR_MEMv_GPRv=5970, + XED_IFORM_XOR_MEMv_IMMb=5971, + XED_IFORM_XOR_MEMv_IMMz=5972, + XED_IFORM_XOR_OrAX_IMMz=5973, + XED_IFORM_XORPD_XMMpd_MEMpd=5974, + XED_IFORM_XORPD_XMMpd_XMMpd=5975, + XED_IFORM_XORPS_XMMps_MEMps=5976, + XED_IFORM_XORPS_XMMps_XMMps=5977, + XED_IFORM_XOR_LOCK_MEMb_GPR8=5978, + XED_IFORM_XOR_LOCK_MEMb_IMMb_80r6=5979, + XED_IFORM_XOR_LOCK_MEMb_IMMb_82r6=5980, + XED_IFORM_XOR_LOCK_MEMv_GPRv=5981, + XED_IFORM_XOR_LOCK_MEMv_IMMb=5982, + XED_IFORM_XOR_LOCK_MEMv_IMMz=5983, + XED_IFORM_XRSTOR_MEMmxsave=5984, + XED_IFORM_XRSTOR64_MEMmxsave=5985, + XED_IFORM_XRSTORS_MEMmxsave=5986, + XED_IFORM_XRSTORS64_MEMmxsave=5987, + XED_IFORM_XSAVE_MEMmxsave=5988, + XED_IFORM_XSAVE64_MEMmxsave=5989, + XED_IFORM_XSAVEC_MEMmxsave=5990, + XED_IFORM_XSAVEC64_MEMmxsave=5991, + XED_IFORM_XSAVEOPT_MEMmxsave=5992, + XED_IFORM_XSAVEOPT64_MEMmxsave=5993, + XED_IFORM_XSAVES_MEMmxsave=5994, + XED_IFORM_XSAVES64_MEMmxsave=5995, + XED_IFORM_XSETBV=5996, + XED_IFORM_XTEST=5997, + XED_IFORM_LAST +} xed_iform_enum_t; + +/// This converts strings to #xed_iform_enum_t types. +/// @param s A C-string. +/// @return #xed_iform_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_iform_enum_t str2xed_iform_enum_t(const char* s); +/// This converts strings to #xed_iform_enum_t types. +/// @param p An enumeration element of type xed_iform_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_iform_enum_t2str(const xed_iform_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_iform_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_iform_enum_t xed_iform_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-iform-map.h b/third_party/xed-intel64/include/xed-iform-map.h new file mode 100644 index 0000000..42ef518 --- /dev/null +++ b/third_party/xed-intel64/include/xed-iform-map.h @@ -0,0 +1,131 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-iform-map.h +/// + +#if !defined(_XED_IFORM_MAP_H_) +# define _XED_IFORM_MAP_H_ + +#include "../../../third_party/xed-intel64/include/xed-category-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-extension-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-iform-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-isa-set-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-types.h" + +/// @ingroup IFORM +/// Statically available information about iforms. +/// Values are returned by #xed_iform_map(). +typedef struct xed_iform_info_s { + xed_iclass_enum_t iclass; + xed_category_enum_t category; + xed_extension_enum_t extension; + xed_isa_set_enum_t isa_set; + + /* if nonzero, index in to the disassembly string table */ + xed_uint32_t string_table_idx; +} xed_iform_info_t; + + +/// @ingroup IFORM +/// Map the #xed_iform_enum_t to a pointer to a #xed_iform_info_t which +/// indicates the #xed_iclass_enum_t, the #xed_category_enum_t and the +/// #xed_extension_enum_t for the iform. Returns 0 if the iform is not a +/// valid iform. +XED_DLL_EXPORT +const xed_iform_info_t* xed_iform_map(xed_iform_enum_t iform); + +/// @ingroup IFORM +/// Return the maximum number of iforms for a particular iclass. This +/// function returns valid data as soon as global data is +/// initialized. (This function does not require a decoded instruction as +/// input). +XED_DLL_EXPORT +xed_uint32_t xed_iform_max_per_iclass(xed_iclass_enum_t iclass); + +/// @ingroup IFORM +/// Return the first of the iforms for a particular iclass. This function +/// returns valid data as soon as global data is initialized. (This +/// function does not require a decoded instruction as input). +XED_DLL_EXPORT +xed_uint32_t xed_iform_first_per_iclass(xed_iclass_enum_t iclass); + +/// @ingroup IFORM +/// Return the iclass for a given iform. This +/// function returns valid data as soon as global data is initialized. (This +/// function does not require a decoded instruction as input). +static +xed_iclass_enum_t XED_INLINE xed_iform_to_iclass(xed_iform_enum_t iform) { + const xed_iform_info_t* ii = xed_iform_map(iform); + if (ii) + return ii->iclass; + return XED_ICLASS_INVALID; +} + +/// @ingroup IFORM +/// Return the category for a given iform. This +/// function returns valid data as soon as global data is initialized. (This +/// function does not require a decoded instruction as input). +XED_DLL_EXPORT +xed_category_enum_t xed_iform_to_category(xed_iform_enum_t iform); + +/// @ingroup IFORM +/// Return the extension for a given iform. This function returns valid +/// data as soon as global data is initialized. (This function does not +/// require a decoded instruction as input). +XED_DLL_EXPORT +xed_extension_enum_t xed_iform_to_extension(xed_iform_enum_t iform); + +/// @ingroup IFORM +/// Return the isa_set for a given iform. This function returns valid data +/// as soon as global data is initialized. (This function does not require +/// a decoded instruction as input). +XED_DLL_EXPORT +xed_isa_set_enum_t xed_iform_to_isa_set(xed_iform_enum_t iform); + +/// @ingroup IFORM +/// Return a pointer to a character string of the iclass. This +/// translates the internal disambiguated names to the more ambiguous +/// names that people like to see. This returns the ATT SYSV-syntax name. +XED_DLL_EXPORT +char const* xed_iform_to_iclass_string_att(xed_iform_enum_t iform); + + +/// @ingroup IFORM +/// Return a pointer to a character string of the iclass. This +/// translates the internal disambiguated names to the more ambiguous +/// names that people like to see. This returns the Intel-syntax name. +XED_DLL_EXPORT +char const* xed_iform_to_iclass_string_intel(xed_iform_enum_t iform); + +#endif diff --git a/third_party/xed-intel64/include/xed-iformfl-enum.h b/third_party/xed-intel64/include/xed-iformfl-enum.h new file mode 100644 index 0000000..d9b7d71 --- /dev/null +++ b/third_party/xed-intel64/include/xed-iformfl-enum.h @@ -0,0 +1,3033 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-iformfl-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_IFORMFL_ENUM_H_) +# define _XED_IFORMFL_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" +typedef enum { + XED_IFORMFL_AAA_FIRST=1, + XED_IFORMFL_AAA_LAST=1, + XED_IFORMFL_AAD_FIRST=2, + XED_IFORMFL_AAD_LAST=2, + XED_IFORMFL_AAM_FIRST=3, + XED_IFORMFL_AAM_LAST=3, + XED_IFORMFL_AAS_FIRST=4, + XED_IFORMFL_AAS_LAST=4, + XED_IFORMFL_ADC_FIRST=5, + XED_IFORMFL_ADC_LAST=22, + XED_IFORMFL_ADCX_FIRST=23, + XED_IFORMFL_ADCX_LAST=26, + XED_IFORMFL_ADC_LOCK_FIRST=27, + XED_IFORMFL_ADC_LOCK_LAST=32, + XED_IFORMFL_ADD_FIRST=33, + XED_IFORMFL_ADD_LAST=50, + XED_IFORMFL_ADDPD_FIRST=51, + XED_IFORMFL_ADDPD_LAST=52, + XED_IFORMFL_ADDPS_FIRST=53, + XED_IFORMFL_ADDPS_LAST=54, + XED_IFORMFL_ADDSD_FIRST=55, + XED_IFORMFL_ADDSD_LAST=56, + XED_IFORMFL_ADDSS_FIRST=57, + XED_IFORMFL_ADDSS_LAST=58, + XED_IFORMFL_ADDSUBPD_FIRST=59, + XED_IFORMFL_ADDSUBPD_LAST=60, + XED_IFORMFL_ADDSUBPS_FIRST=61, + XED_IFORMFL_ADDSUBPS_LAST=62, + XED_IFORMFL_ADD_LOCK_FIRST=63, + XED_IFORMFL_ADD_LOCK_LAST=68, + XED_IFORMFL_ADOX_FIRST=69, + XED_IFORMFL_ADOX_LAST=72, + XED_IFORMFL_AESDEC_FIRST=73, + XED_IFORMFL_AESDEC_LAST=74, + XED_IFORMFL_AESDECLAST_FIRST=75, + XED_IFORMFL_AESDECLAST_LAST=76, + XED_IFORMFL_AESENC_FIRST=77, + XED_IFORMFL_AESENC_LAST=78, + XED_IFORMFL_AESENCLAST_FIRST=79, + XED_IFORMFL_AESENCLAST_LAST=80, + XED_IFORMFL_AESIMC_FIRST=81, + XED_IFORMFL_AESIMC_LAST=82, + XED_IFORMFL_AESKEYGENASSIST_FIRST=83, + XED_IFORMFL_AESKEYGENASSIST_LAST=84, + XED_IFORMFL_AND_FIRST=85, + XED_IFORMFL_AND_LAST=102, + XED_IFORMFL_ANDN_FIRST=103, + XED_IFORMFL_ANDN_LAST=106, + XED_IFORMFL_ANDNPD_FIRST=107, + XED_IFORMFL_ANDNPD_LAST=108, + XED_IFORMFL_ANDNPS_FIRST=109, + XED_IFORMFL_ANDNPS_LAST=110, + XED_IFORMFL_ANDPD_FIRST=111, + XED_IFORMFL_ANDPD_LAST=112, + XED_IFORMFL_ANDPS_FIRST=113, + XED_IFORMFL_ANDPS_LAST=114, + XED_IFORMFL_AND_LOCK_FIRST=115, + XED_IFORMFL_AND_LOCK_LAST=120, + XED_IFORMFL_ARPL_FIRST=121, + XED_IFORMFL_ARPL_LAST=122, + XED_IFORMFL_BEXTR_FIRST=123, + XED_IFORMFL_BEXTR_LAST=126, + XED_IFORMFL_BEXTR_XOP_FIRST=127, + XED_IFORMFL_BEXTR_XOP_LAST=128, + XED_IFORMFL_BLCFILL_FIRST=129, + XED_IFORMFL_BLCFILL_LAST=130, + XED_IFORMFL_BLCI_FIRST=131, + XED_IFORMFL_BLCI_LAST=132, + XED_IFORMFL_BLCIC_FIRST=133, + XED_IFORMFL_BLCIC_LAST=134, + XED_IFORMFL_BLCMSK_FIRST=135, + XED_IFORMFL_BLCMSK_LAST=136, + XED_IFORMFL_BLCS_FIRST=137, + XED_IFORMFL_BLCS_LAST=138, + XED_IFORMFL_BLENDPD_FIRST=139, + XED_IFORMFL_BLENDPD_LAST=140, + XED_IFORMFL_BLENDPS_FIRST=141, + XED_IFORMFL_BLENDPS_LAST=142, + XED_IFORMFL_BLENDVPD_FIRST=143, + XED_IFORMFL_BLENDVPD_LAST=144, + XED_IFORMFL_BLENDVPS_FIRST=145, + XED_IFORMFL_BLENDVPS_LAST=146, + XED_IFORMFL_BLSFILL_FIRST=147, + XED_IFORMFL_BLSFILL_LAST=148, + XED_IFORMFL_BLSI_FIRST=149, + XED_IFORMFL_BLSI_LAST=152, + XED_IFORMFL_BLSIC_FIRST=153, + XED_IFORMFL_BLSIC_LAST=154, + XED_IFORMFL_BLSMSK_FIRST=155, + XED_IFORMFL_BLSMSK_LAST=158, + XED_IFORMFL_BLSR_FIRST=159, + XED_IFORMFL_BLSR_LAST=162, + XED_IFORMFL_BNDCL_FIRST=163, + XED_IFORMFL_BNDCL_LAST=165, + XED_IFORMFL_BNDCN_FIRST=166, + XED_IFORMFL_BNDCN_LAST=168, + XED_IFORMFL_BNDCU_FIRST=169, + XED_IFORMFL_BNDCU_LAST=171, + XED_IFORMFL_BNDLDX_FIRST=172, + XED_IFORMFL_BNDLDX_LAST=173, + XED_IFORMFL_BNDMK_FIRST=174, + XED_IFORMFL_BNDMK_LAST=174, + XED_IFORMFL_BNDMOV_FIRST=175, + XED_IFORMFL_BNDMOV_LAST=179, + XED_IFORMFL_BNDSTX_FIRST=180, + XED_IFORMFL_BNDSTX_LAST=181, + XED_IFORMFL_BOUND_FIRST=182, + XED_IFORMFL_BOUND_LAST=183, + XED_IFORMFL_BSF_FIRST=184, + XED_IFORMFL_BSF_LAST=185, + XED_IFORMFL_BSR_FIRST=186, + XED_IFORMFL_BSR_LAST=187, + XED_IFORMFL_BSWAP_FIRST=188, + XED_IFORMFL_BSWAP_LAST=188, + XED_IFORMFL_BT_FIRST=189, + XED_IFORMFL_BT_LAST=192, + XED_IFORMFL_BTC_FIRST=193, + XED_IFORMFL_BTC_LAST=196, + XED_IFORMFL_BTC_LOCK_FIRST=197, + XED_IFORMFL_BTC_LOCK_LAST=198, + XED_IFORMFL_BTR_FIRST=199, + XED_IFORMFL_BTR_LAST=202, + XED_IFORMFL_BTR_LOCK_FIRST=203, + XED_IFORMFL_BTR_LOCK_LAST=204, + XED_IFORMFL_BTS_FIRST=205, + XED_IFORMFL_BTS_LAST=208, + XED_IFORMFL_BTS_LOCK_FIRST=209, + XED_IFORMFL_BTS_LOCK_LAST=210, + XED_IFORMFL_BZHI_FIRST=211, + XED_IFORMFL_BZHI_LAST=214, + XED_IFORMFL_CALL_FAR_FIRST=215, + XED_IFORMFL_CALL_FAR_LAST=216, + XED_IFORMFL_CALL_NEAR_FIRST=217, + XED_IFORMFL_CALL_NEAR_LAST=220, + XED_IFORMFL_CBW_FIRST=221, + XED_IFORMFL_CBW_LAST=221, + XED_IFORMFL_CDQ_FIRST=222, + XED_IFORMFL_CDQ_LAST=222, + XED_IFORMFL_CDQE_FIRST=223, + XED_IFORMFL_CDQE_LAST=223, + XED_IFORMFL_CLAC_FIRST=224, + XED_IFORMFL_CLAC_LAST=224, + XED_IFORMFL_CLC_FIRST=225, + XED_IFORMFL_CLC_LAST=225, + XED_IFORMFL_CLD_FIRST=226, + XED_IFORMFL_CLD_LAST=226, + XED_IFORMFL_CLFLUSH_FIRST=227, + XED_IFORMFL_CLFLUSH_LAST=227, + XED_IFORMFL_CLFLUSHOPT_FIRST=228, + XED_IFORMFL_CLFLUSHOPT_LAST=228, + XED_IFORMFL_CLGI_FIRST=229, + XED_IFORMFL_CLGI_LAST=229, + XED_IFORMFL_CLI_FIRST=230, + XED_IFORMFL_CLI_LAST=230, + XED_IFORMFL_CLTS_FIRST=231, + XED_IFORMFL_CLTS_LAST=231, + XED_IFORMFL_CLWB_FIRST=232, + XED_IFORMFL_CLWB_LAST=232, + XED_IFORMFL_CMC_FIRST=233, + XED_IFORMFL_CMC_LAST=233, + XED_IFORMFL_CMOVB_FIRST=234, + XED_IFORMFL_CMOVB_LAST=235, + XED_IFORMFL_CMOVBE_FIRST=236, + XED_IFORMFL_CMOVBE_LAST=237, + XED_IFORMFL_CMOVL_FIRST=238, + XED_IFORMFL_CMOVL_LAST=239, + XED_IFORMFL_CMOVLE_FIRST=240, + XED_IFORMFL_CMOVLE_LAST=241, + XED_IFORMFL_CMOVNB_FIRST=242, + XED_IFORMFL_CMOVNB_LAST=243, + XED_IFORMFL_CMOVNBE_FIRST=244, + XED_IFORMFL_CMOVNBE_LAST=245, + XED_IFORMFL_CMOVNL_FIRST=246, + XED_IFORMFL_CMOVNL_LAST=247, + XED_IFORMFL_CMOVNLE_FIRST=248, + XED_IFORMFL_CMOVNLE_LAST=249, + XED_IFORMFL_CMOVNO_FIRST=250, + XED_IFORMFL_CMOVNO_LAST=251, + XED_IFORMFL_CMOVNP_FIRST=252, + XED_IFORMFL_CMOVNP_LAST=253, + XED_IFORMFL_CMOVNS_FIRST=254, + XED_IFORMFL_CMOVNS_LAST=255, + XED_IFORMFL_CMOVNZ_FIRST=256, + XED_IFORMFL_CMOVNZ_LAST=257, + XED_IFORMFL_CMOVO_FIRST=258, + XED_IFORMFL_CMOVO_LAST=259, + XED_IFORMFL_CMOVP_FIRST=260, + XED_IFORMFL_CMOVP_LAST=261, + XED_IFORMFL_CMOVS_FIRST=262, + XED_IFORMFL_CMOVS_LAST=263, + XED_IFORMFL_CMOVZ_FIRST=264, + XED_IFORMFL_CMOVZ_LAST=265, + XED_IFORMFL_CMP_FIRST=266, + XED_IFORMFL_CMP_LAST=283, + XED_IFORMFL_CMPPD_FIRST=284, + XED_IFORMFL_CMPPD_LAST=285, + XED_IFORMFL_CMPPS_FIRST=286, + XED_IFORMFL_CMPPS_LAST=287, + XED_IFORMFL_CMPSB_FIRST=288, + XED_IFORMFL_CMPSB_LAST=288, + XED_IFORMFL_CMPSD_FIRST=289, + XED_IFORMFL_CMPSD_LAST=289, + XED_IFORMFL_CMPSD_XMM_FIRST=290, + XED_IFORMFL_CMPSD_XMM_LAST=291, + XED_IFORMFL_CMPSQ_FIRST=292, + XED_IFORMFL_CMPSQ_LAST=292, + XED_IFORMFL_CMPSS_FIRST=293, + XED_IFORMFL_CMPSS_LAST=294, + XED_IFORMFL_CMPSW_FIRST=295, + XED_IFORMFL_CMPSW_LAST=295, + XED_IFORMFL_CMPXCHG_FIRST=296, + XED_IFORMFL_CMPXCHG_LAST=299, + XED_IFORMFL_CMPXCHG16B_FIRST=300, + XED_IFORMFL_CMPXCHG16B_LAST=300, + XED_IFORMFL_CMPXCHG16B_LOCK_FIRST=301, + XED_IFORMFL_CMPXCHG16B_LOCK_LAST=301, + XED_IFORMFL_CMPXCHG8B_FIRST=302, + XED_IFORMFL_CMPXCHG8B_LAST=302, + XED_IFORMFL_CMPXCHG8B_LOCK_FIRST=303, + XED_IFORMFL_CMPXCHG8B_LOCK_LAST=303, + XED_IFORMFL_CMPXCHG_LOCK_FIRST=304, + XED_IFORMFL_CMPXCHG_LOCK_LAST=305, + XED_IFORMFL_COMISD_FIRST=306, + XED_IFORMFL_COMISD_LAST=307, + XED_IFORMFL_COMISS_FIRST=308, + XED_IFORMFL_COMISS_LAST=309, + XED_IFORMFL_CPUID_FIRST=310, + XED_IFORMFL_CPUID_LAST=310, + XED_IFORMFL_CQO_FIRST=311, + XED_IFORMFL_CQO_LAST=311, + XED_IFORMFL_CRC32_FIRST=312, + XED_IFORMFL_CRC32_LAST=315, + XED_IFORMFL_CVTDQ2PD_FIRST=316, + XED_IFORMFL_CVTDQ2PD_LAST=317, + XED_IFORMFL_CVTDQ2PS_FIRST=318, + XED_IFORMFL_CVTDQ2PS_LAST=319, + XED_IFORMFL_CVTPD2DQ_FIRST=320, + XED_IFORMFL_CVTPD2DQ_LAST=321, + XED_IFORMFL_CVTPD2PI_FIRST=322, + XED_IFORMFL_CVTPD2PI_LAST=323, + XED_IFORMFL_CVTPD2PS_FIRST=324, + XED_IFORMFL_CVTPD2PS_LAST=325, + XED_IFORMFL_CVTPI2PD_FIRST=326, + XED_IFORMFL_CVTPI2PD_LAST=327, + XED_IFORMFL_CVTPI2PS_FIRST=328, + XED_IFORMFL_CVTPI2PS_LAST=329, + XED_IFORMFL_CVTPS2DQ_FIRST=330, + XED_IFORMFL_CVTPS2DQ_LAST=331, + XED_IFORMFL_CVTPS2PD_FIRST=332, + XED_IFORMFL_CVTPS2PD_LAST=333, + XED_IFORMFL_CVTPS2PI_FIRST=334, + XED_IFORMFL_CVTPS2PI_LAST=335, + XED_IFORMFL_CVTSD2SI_FIRST=336, + XED_IFORMFL_CVTSD2SI_LAST=339, + XED_IFORMFL_CVTSD2SS_FIRST=340, + XED_IFORMFL_CVTSD2SS_LAST=341, + XED_IFORMFL_CVTSI2SD_FIRST=342, + XED_IFORMFL_CVTSI2SD_LAST=345, + XED_IFORMFL_CVTSI2SS_FIRST=346, + XED_IFORMFL_CVTSI2SS_LAST=349, + XED_IFORMFL_CVTSS2SD_FIRST=350, + XED_IFORMFL_CVTSS2SD_LAST=351, + XED_IFORMFL_CVTSS2SI_FIRST=352, + XED_IFORMFL_CVTSS2SI_LAST=355, + XED_IFORMFL_CVTTPD2DQ_FIRST=356, + XED_IFORMFL_CVTTPD2DQ_LAST=357, + XED_IFORMFL_CVTTPD2PI_FIRST=358, + XED_IFORMFL_CVTTPD2PI_LAST=359, + XED_IFORMFL_CVTTPS2DQ_FIRST=360, + XED_IFORMFL_CVTTPS2DQ_LAST=361, + XED_IFORMFL_CVTTPS2PI_FIRST=362, + XED_IFORMFL_CVTTPS2PI_LAST=363, + XED_IFORMFL_CVTTSD2SI_FIRST=364, + XED_IFORMFL_CVTTSD2SI_LAST=367, + XED_IFORMFL_CVTTSS2SI_FIRST=368, + XED_IFORMFL_CVTTSS2SI_LAST=371, + XED_IFORMFL_CWD_FIRST=372, + XED_IFORMFL_CWD_LAST=372, + XED_IFORMFL_CWDE_FIRST=373, + XED_IFORMFL_CWDE_LAST=373, + XED_IFORMFL_DAA_FIRST=374, + XED_IFORMFL_DAA_LAST=374, + XED_IFORMFL_DAS_FIRST=375, + XED_IFORMFL_DAS_LAST=375, + XED_IFORMFL_DEC_FIRST=376, + XED_IFORMFL_DEC_LAST=380, + XED_IFORMFL_DEC_LOCK_FIRST=381, + XED_IFORMFL_DEC_LOCK_LAST=382, + XED_IFORMFL_DIV_FIRST=383, + XED_IFORMFL_DIV_LAST=386, + XED_IFORMFL_DIVPD_FIRST=387, + XED_IFORMFL_DIVPD_LAST=388, + XED_IFORMFL_DIVPS_FIRST=389, + XED_IFORMFL_DIVPS_LAST=390, + XED_IFORMFL_DIVSD_FIRST=391, + XED_IFORMFL_DIVSD_LAST=392, + XED_IFORMFL_DIVSS_FIRST=393, + XED_IFORMFL_DIVSS_LAST=394, + XED_IFORMFL_DPPD_FIRST=395, + XED_IFORMFL_DPPD_LAST=396, + XED_IFORMFL_DPPS_FIRST=397, + XED_IFORMFL_DPPS_LAST=398, + XED_IFORMFL_EMMS_FIRST=399, + XED_IFORMFL_EMMS_LAST=399, + XED_IFORMFL_ENCLS_FIRST=400, + XED_IFORMFL_ENCLS_LAST=400, + XED_IFORMFL_ENCLU_FIRST=401, + XED_IFORMFL_ENCLU_LAST=401, + XED_IFORMFL_ENTER_FIRST=402, + XED_IFORMFL_ENTER_LAST=402, + XED_IFORMFL_EXTRACTPS_FIRST=403, + XED_IFORMFL_EXTRACTPS_LAST=404, + XED_IFORMFL_EXTRQ_FIRST=405, + XED_IFORMFL_EXTRQ_LAST=406, + XED_IFORMFL_F2XM1_FIRST=407, + XED_IFORMFL_F2XM1_LAST=407, + XED_IFORMFL_FABS_FIRST=408, + XED_IFORMFL_FABS_LAST=408, + XED_IFORMFL_FADD_FIRST=409, + XED_IFORMFL_FADD_LAST=412, + XED_IFORMFL_FADDP_FIRST=413, + XED_IFORMFL_FADDP_LAST=413, + XED_IFORMFL_FBLD_FIRST=414, + XED_IFORMFL_FBLD_LAST=414, + XED_IFORMFL_FBSTP_FIRST=415, + XED_IFORMFL_FBSTP_LAST=415, + XED_IFORMFL_FCHS_FIRST=416, + XED_IFORMFL_FCHS_LAST=416, + XED_IFORMFL_FCMOVB_FIRST=417, + XED_IFORMFL_FCMOVB_LAST=417, + XED_IFORMFL_FCMOVBE_FIRST=418, + XED_IFORMFL_FCMOVBE_LAST=418, + XED_IFORMFL_FCMOVE_FIRST=419, + XED_IFORMFL_FCMOVE_LAST=419, + XED_IFORMFL_FCMOVNB_FIRST=420, + XED_IFORMFL_FCMOVNB_LAST=420, + XED_IFORMFL_FCMOVNBE_FIRST=421, + XED_IFORMFL_FCMOVNBE_LAST=421, + XED_IFORMFL_FCMOVNE_FIRST=422, + XED_IFORMFL_FCMOVNE_LAST=422, + XED_IFORMFL_FCMOVNU_FIRST=423, + XED_IFORMFL_FCMOVNU_LAST=423, + XED_IFORMFL_FCMOVU_FIRST=424, + XED_IFORMFL_FCMOVU_LAST=424, + XED_IFORMFL_FCOM_FIRST=425, + XED_IFORMFL_FCOM_LAST=428, + XED_IFORMFL_FCOMI_FIRST=429, + XED_IFORMFL_FCOMI_LAST=429, + XED_IFORMFL_FCOMIP_FIRST=430, + XED_IFORMFL_FCOMIP_LAST=430, + XED_IFORMFL_FCOMP_FIRST=431, + XED_IFORMFL_FCOMP_LAST=435, + XED_IFORMFL_FCOMPP_FIRST=436, + XED_IFORMFL_FCOMPP_LAST=436, + XED_IFORMFL_FCOS_FIRST=437, + XED_IFORMFL_FCOS_LAST=437, + XED_IFORMFL_FDECSTP_FIRST=438, + XED_IFORMFL_FDECSTP_LAST=438, + XED_IFORMFL_FDISI8087_NOP_FIRST=439, + XED_IFORMFL_FDISI8087_NOP_LAST=439, + XED_IFORMFL_FDIV_FIRST=440, + XED_IFORMFL_FDIV_LAST=443, + XED_IFORMFL_FDIVP_FIRST=444, + XED_IFORMFL_FDIVP_LAST=444, + XED_IFORMFL_FDIVR_FIRST=445, + XED_IFORMFL_FDIVR_LAST=448, + XED_IFORMFL_FDIVRP_FIRST=449, + XED_IFORMFL_FDIVRP_LAST=449, + XED_IFORMFL_FEMMS_FIRST=450, + XED_IFORMFL_FEMMS_LAST=450, + XED_IFORMFL_FENI8087_NOP_FIRST=451, + XED_IFORMFL_FENI8087_NOP_LAST=451, + XED_IFORMFL_FFREE_FIRST=452, + XED_IFORMFL_FFREE_LAST=452, + XED_IFORMFL_FFREEP_FIRST=453, + XED_IFORMFL_FFREEP_LAST=453, + XED_IFORMFL_FIADD_FIRST=454, + XED_IFORMFL_FIADD_LAST=455, + XED_IFORMFL_FICOM_FIRST=456, + XED_IFORMFL_FICOM_LAST=457, + XED_IFORMFL_FICOMP_FIRST=458, + XED_IFORMFL_FICOMP_LAST=459, + XED_IFORMFL_FIDIV_FIRST=460, + XED_IFORMFL_FIDIV_LAST=461, + XED_IFORMFL_FIDIVR_FIRST=462, + XED_IFORMFL_FIDIVR_LAST=463, + XED_IFORMFL_FILD_FIRST=464, + XED_IFORMFL_FILD_LAST=466, + XED_IFORMFL_FIMUL_FIRST=467, + XED_IFORMFL_FIMUL_LAST=468, + XED_IFORMFL_FINCSTP_FIRST=469, + XED_IFORMFL_FINCSTP_LAST=469, + XED_IFORMFL_FIST_FIRST=470, + XED_IFORMFL_FIST_LAST=471, + XED_IFORMFL_FISTP_FIRST=472, + XED_IFORMFL_FISTP_LAST=474, + XED_IFORMFL_FISTTP_FIRST=475, + XED_IFORMFL_FISTTP_LAST=477, + XED_IFORMFL_FISUB_FIRST=478, + XED_IFORMFL_FISUB_LAST=479, + XED_IFORMFL_FISUBR_FIRST=480, + XED_IFORMFL_FISUBR_LAST=481, + XED_IFORMFL_FLD_FIRST=482, + XED_IFORMFL_FLD_LAST=485, + XED_IFORMFL_FLD1_FIRST=486, + XED_IFORMFL_FLD1_LAST=486, + XED_IFORMFL_FLDCW_FIRST=487, + XED_IFORMFL_FLDCW_LAST=487, + XED_IFORMFL_FLDENV_FIRST=488, + XED_IFORMFL_FLDENV_LAST=489, + XED_IFORMFL_FLDL2E_FIRST=490, + XED_IFORMFL_FLDL2E_LAST=490, + XED_IFORMFL_FLDL2T_FIRST=491, + XED_IFORMFL_FLDL2T_LAST=491, + XED_IFORMFL_FLDLG2_FIRST=492, + XED_IFORMFL_FLDLG2_LAST=492, + XED_IFORMFL_FLDLN2_FIRST=493, + XED_IFORMFL_FLDLN2_LAST=493, + XED_IFORMFL_FLDPI_FIRST=494, + XED_IFORMFL_FLDPI_LAST=494, + XED_IFORMFL_FLDZ_FIRST=495, + XED_IFORMFL_FLDZ_LAST=495, + XED_IFORMFL_FMUL_FIRST=496, + XED_IFORMFL_FMUL_LAST=499, + XED_IFORMFL_FMULP_FIRST=500, + XED_IFORMFL_FMULP_LAST=500, + XED_IFORMFL_FNCLEX_FIRST=501, + XED_IFORMFL_FNCLEX_LAST=501, + XED_IFORMFL_FNINIT_FIRST=502, + XED_IFORMFL_FNINIT_LAST=502, + XED_IFORMFL_FNOP_FIRST=503, + XED_IFORMFL_FNOP_LAST=503, + XED_IFORMFL_FNSAVE_FIRST=504, + XED_IFORMFL_FNSAVE_LAST=505, + XED_IFORMFL_FNSTCW_FIRST=506, + XED_IFORMFL_FNSTCW_LAST=506, + XED_IFORMFL_FNSTENV_FIRST=507, + XED_IFORMFL_FNSTENV_LAST=508, + XED_IFORMFL_FNSTSW_FIRST=509, + XED_IFORMFL_FNSTSW_LAST=510, + XED_IFORMFL_FPATAN_FIRST=511, + XED_IFORMFL_FPATAN_LAST=511, + XED_IFORMFL_FPREM_FIRST=512, + XED_IFORMFL_FPREM_LAST=512, + XED_IFORMFL_FPREM1_FIRST=513, + XED_IFORMFL_FPREM1_LAST=513, + XED_IFORMFL_FPTAN_FIRST=514, + XED_IFORMFL_FPTAN_LAST=514, + XED_IFORMFL_FRNDINT_FIRST=515, + XED_IFORMFL_FRNDINT_LAST=515, + XED_IFORMFL_FRSTOR_FIRST=516, + XED_IFORMFL_FRSTOR_LAST=517, + XED_IFORMFL_FSCALE_FIRST=518, + XED_IFORMFL_FSCALE_LAST=518, + XED_IFORMFL_FSETPM287_NOP_FIRST=519, + XED_IFORMFL_FSETPM287_NOP_LAST=519, + XED_IFORMFL_FSIN_FIRST=520, + XED_IFORMFL_FSIN_LAST=520, + XED_IFORMFL_FSINCOS_FIRST=521, + XED_IFORMFL_FSINCOS_LAST=521, + XED_IFORMFL_FSQRT_FIRST=522, + XED_IFORMFL_FSQRT_LAST=522, + XED_IFORMFL_FST_FIRST=523, + XED_IFORMFL_FST_LAST=525, + XED_IFORMFL_FSTP_FIRST=526, + XED_IFORMFL_FSTP_LAST=531, + XED_IFORMFL_FSTPNCE_FIRST=532, + XED_IFORMFL_FSTPNCE_LAST=532, + XED_IFORMFL_FSUB_FIRST=533, + XED_IFORMFL_FSUB_LAST=536, + XED_IFORMFL_FSUBP_FIRST=537, + XED_IFORMFL_FSUBP_LAST=537, + XED_IFORMFL_FSUBR_FIRST=538, + XED_IFORMFL_FSUBR_LAST=541, + XED_IFORMFL_FSUBRP_FIRST=542, + XED_IFORMFL_FSUBRP_LAST=542, + XED_IFORMFL_FTST_FIRST=543, + XED_IFORMFL_FTST_LAST=543, + XED_IFORMFL_FUCOM_FIRST=544, + XED_IFORMFL_FUCOM_LAST=544, + XED_IFORMFL_FUCOMI_FIRST=545, + XED_IFORMFL_FUCOMI_LAST=545, + XED_IFORMFL_FUCOMIP_FIRST=546, + XED_IFORMFL_FUCOMIP_LAST=546, + XED_IFORMFL_FUCOMP_FIRST=547, + XED_IFORMFL_FUCOMP_LAST=547, + XED_IFORMFL_FUCOMPP_FIRST=548, + XED_IFORMFL_FUCOMPP_LAST=548, + XED_IFORMFL_FWAIT_FIRST=549, + XED_IFORMFL_FWAIT_LAST=549, + XED_IFORMFL_FXAM_FIRST=550, + XED_IFORMFL_FXAM_LAST=550, + XED_IFORMFL_FXCH_FIRST=551, + XED_IFORMFL_FXCH_LAST=553, + XED_IFORMFL_FXRSTOR_FIRST=554, + XED_IFORMFL_FXRSTOR_LAST=554, + XED_IFORMFL_FXRSTOR64_FIRST=555, + XED_IFORMFL_FXRSTOR64_LAST=555, + XED_IFORMFL_FXSAVE_FIRST=556, + XED_IFORMFL_FXSAVE_LAST=556, + XED_IFORMFL_FXSAVE64_FIRST=557, + XED_IFORMFL_FXSAVE64_LAST=557, + XED_IFORMFL_FXTRACT_FIRST=558, + XED_IFORMFL_FXTRACT_LAST=558, + XED_IFORMFL_FYL2X_FIRST=559, + XED_IFORMFL_FYL2X_LAST=559, + XED_IFORMFL_FYL2XP1_FIRST=560, + XED_IFORMFL_FYL2XP1_LAST=560, + XED_IFORMFL_GETSEC_FIRST=561, + XED_IFORMFL_GETSEC_LAST=561, + XED_IFORMFL_HADDPD_FIRST=562, + XED_IFORMFL_HADDPD_LAST=563, + XED_IFORMFL_HADDPS_FIRST=564, + XED_IFORMFL_HADDPS_LAST=565, + XED_IFORMFL_HLT_FIRST=566, + XED_IFORMFL_HLT_LAST=566, + XED_IFORMFL_HSUBPD_FIRST=567, + XED_IFORMFL_HSUBPD_LAST=568, + XED_IFORMFL_HSUBPS_FIRST=569, + XED_IFORMFL_HSUBPS_LAST=570, + XED_IFORMFL_IDIV_FIRST=571, + XED_IFORMFL_IDIV_LAST=574, + XED_IFORMFL_IMUL_FIRST=575, + XED_IFORMFL_IMUL_LAST=584, + XED_IFORMFL_IN_FIRST=585, + XED_IFORMFL_IN_LAST=588, + XED_IFORMFL_INC_FIRST=589, + XED_IFORMFL_INC_LAST=593, + XED_IFORMFL_INC_LOCK_FIRST=594, + XED_IFORMFL_INC_LOCK_LAST=595, + XED_IFORMFL_INSB_FIRST=596, + XED_IFORMFL_INSB_LAST=596, + XED_IFORMFL_INSD_FIRST=597, + XED_IFORMFL_INSD_LAST=597, + XED_IFORMFL_INSERTPS_FIRST=598, + XED_IFORMFL_INSERTPS_LAST=599, + XED_IFORMFL_INSERTQ_FIRST=600, + XED_IFORMFL_INSERTQ_LAST=601, + XED_IFORMFL_INSW_FIRST=602, + XED_IFORMFL_INSW_LAST=602, + XED_IFORMFL_INT_FIRST=603, + XED_IFORMFL_INT_LAST=603, + XED_IFORMFL_INT1_FIRST=604, + XED_IFORMFL_INT1_LAST=604, + XED_IFORMFL_INT3_FIRST=605, + XED_IFORMFL_INT3_LAST=605, + XED_IFORMFL_INTO_FIRST=606, + XED_IFORMFL_INTO_LAST=606, + XED_IFORMFL_INVD_FIRST=607, + XED_IFORMFL_INVD_LAST=607, + XED_IFORMFL_INVEPT_FIRST=608, + XED_IFORMFL_INVEPT_LAST=609, + XED_IFORMFL_INVLPG_FIRST=610, + XED_IFORMFL_INVLPG_LAST=610, + XED_IFORMFL_INVLPGA_FIRST=611, + XED_IFORMFL_INVLPGA_LAST=611, + XED_IFORMFL_INVPCID_FIRST=612, + XED_IFORMFL_INVPCID_LAST=613, + XED_IFORMFL_INVVPID_FIRST=614, + XED_IFORMFL_INVVPID_LAST=615, + XED_IFORMFL_IRET_FIRST=616, + XED_IFORMFL_IRET_LAST=616, + XED_IFORMFL_IRETD_FIRST=617, + XED_IFORMFL_IRETD_LAST=617, + XED_IFORMFL_IRETQ_FIRST=618, + XED_IFORMFL_IRETQ_LAST=618, + XED_IFORMFL_JB_FIRST=619, + XED_IFORMFL_JB_LAST=621, + XED_IFORMFL_JBE_FIRST=622, + XED_IFORMFL_JBE_LAST=624, + XED_IFORMFL_JCXZ_FIRST=625, + XED_IFORMFL_JCXZ_LAST=625, + XED_IFORMFL_JECXZ_FIRST=626, + XED_IFORMFL_JECXZ_LAST=626, + XED_IFORMFL_JL_FIRST=627, + XED_IFORMFL_JL_LAST=629, + XED_IFORMFL_JLE_FIRST=630, + XED_IFORMFL_JLE_LAST=632, + XED_IFORMFL_JMP_FIRST=633, + XED_IFORMFL_JMP_LAST=637, + XED_IFORMFL_JMP_FAR_FIRST=638, + XED_IFORMFL_JMP_FAR_LAST=639, + XED_IFORMFL_JNB_FIRST=640, + XED_IFORMFL_JNB_LAST=642, + XED_IFORMFL_JNBE_FIRST=643, + XED_IFORMFL_JNBE_LAST=645, + XED_IFORMFL_JNL_FIRST=646, + XED_IFORMFL_JNL_LAST=648, + XED_IFORMFL_JNLE_FIRST=649, + XED_IFORMFL_JNLE_LAST=651, + XED_IFORMFL_JNO_FIRST=652, + XED_IFORMFL_JNO_LAST=654, + XED_IFORMFL_JNP_FIRST=655, + XED_IFORMFL_JNP_LAST=657, + XED_IFORMFL_JNS_FIRST=658, + XED_IFORMFL_JNS_LAST=660, + XED_IFORMFL_JNZ_FIRST=661, + XED_IFORMFL_JNZ_LAST=663, + XED_IFORMFL_JO_FIRST=664, + XED_IFORMFL_JO_LAST=666, + XED_IFORMFL_JP_FIRST=667, + XED_IFORMFL_JP_LAST=669, + XED_IFORMFL_JRCXZ_FIRST=670, + XED_IFORMFL_JRCXZ_LAST=670, + XED_IFORMFL_JS_FIRST=671, + XED_IFORMFL_JS_LAST=673, + XED_IFORMFL_JZ_FIRST=674, + XED_IFORMFL_JZ_LAST=676, + XED_IFORMFL_KADDB_FIRST=677, + XED_IFORMFL_KADDB_LAST=677, + XED_IFORMFL_KADDD_FIRST=678, + XED_IFORMFL_KADDD_LAST=678, + XED_IFORMFL_KADDQ_FIRST=679, + XED_IFORMFL_KADDQ_LAST=679, + XED_IFORMFL_KADDW_FIRST=680, + XED_IFORMFL_KADDW_LAST=680, + XED_IFORMFL_KANDB_FIRST=681, + XED_IFORMFL_KANDB_LAST=681, + XED_IFORMFL_KANDD_FIRST=682, + XED_IFORMFL_KANDD_LAST=682, + XED_IFORMFL_KANDNB_FIRST=683, + XED_IFORMFL_KANDNB_LAST=683, + XED_IFORMFL_KANDND_FIRST=684, + XED_IFORMFL_KANDND_LAST=684, + XED_IFORMFL_KANDNQ_FIRST=685, + XED_IFORMFL_KANDNQ_LAST=685, + XED_IFORMFL_KANDNW_FIRST=686, + XED_IFORMFL_KANDNW_LAST=686, + XED_IFORMFL_KANDQ_FIRST=687, + XED_IFORMFL_KANDQ_LAST=687, + XED_IFORMFL_KANDW_FIRST=688, + XED_IFORMFL_KANDW_LAST=688, + XED_IFORMFL_KMOVB_FIRST=689, + XED_IFORMFL_KMOVB_LAST=693, + XED_IFORMFL_KMOVD_FIRST=694, + XED_IFORMFL_KMOVD_LAST=698, + XED_IFORMFL_KMOVQ_FIRST=699, + XED_IFORMFL_KMOVQ_LAST=703, + XED_IFORMFL_KMOVW_FIRST=704, + XED_IFORMFL_KMOVW_LAST=708, + XED_IFORMFL_KNOTB_FIRST=709, + XED_IFORMFL_KNOTB_LAST=709, + XED_IFORMFL_KNOTD_FIRST=710, + XED_IFORMFL_KNOTD_LAST=710, + XED_IFORMFL_KNOTQ_FIRST=711, + XED_IFORMFL_KNOTQ_LAST=711, + XED_IFORMFL_KNOTW_FIRST=712, + XED_IFORMFL_KNOTW_LAST=712, + XED_IFORMFL_KORB_FIRST=713, + XED_IFORMFL_KORB_LAST=713, + XED_IFORMFL_KORD_FIRST=714, + XED_IFORMFL_KORD_LAST=714, + XED_IFORMFL_KORQ_FIRST=715, + XED_IFORMFL_KORQ_LAST=715, + XED_IFORMFL_KORTESTB_FIRST=716, + XED_IFORMFL_KORTESTB_LAST=716, + XED_IFORMFL_KORTESTD_FIRST=717, + XED_IFORMFL_KORTESTD_LAST=717, + XED_IFORMFL_KORTESTQ_FIRST=718, + XED_IFORMFL_KORTESTQ_LAST=718, + XED_IFORMFL_KORTESTW_FIRST=719, + XED_IFORMFL_KORTESTW_LAST=719, + XED_IFORMFL_KORW_FIRST=720, + XED_IFORMFL_KORW_LAST=720, + XED_IFORMFL_KSHIFTLB_FIRST=721, + XED_IFORMFL_KSHIFTLB_LAST=721, + XED_IFORMFL_KSHIFTLD_FIRST=722, + XED_IFORMFL_KSHIFTLD_LAST=722, + XED_IFORMFL_KSHIFTLQ_FIRST=723, + XED_IFORMFL_KSHIFTLQ_LAST=723, + XED_IFORMFL_KSHIFTLW_FIRST=724, + XED_IFORMFL_KSHIFTLW_LAST=724, + XED_IFORMFL_KSHIFTRB_FIRST=725, + XED_IFORMFL_KSHIFTRB_LAST=725, + XED_IFORMFL_KSHIFTRD_FIRST=726, + XED_IFORMFL_KSHIFTRD_LAST=726, + XED_IFORMFL_KSHIFTRQ_FIRST=727, + XED_IFORMFL_KSHIFTRQ_LAST=727, + XED_IFORMFL_KSHIFTRW_FIRST=728, + XED_IFORMFL_KSHIFTRW_LAST=728, + XED_IFORMFL_KTESTB_FIRST=729, + XED_IFORMFL_KTESTB_LAST=729, + XED_IFORMFL_KTESTD_FIRST=730, + XED_IFORMFL_KTESTD_LAST=730, + XED_IFORMFL_KTESTQ_FIRST=731, + XED_IFORMFL_KTESTQ_LAST=731, + XED_IFORMFL_KTESTW_FIRST=732, + XED_IFORMFL_KTESTW_LAST=732, + XED_IFORMFL_KUNPCKBW_FIRST=733, + XED_IFORMFL_KUNPCKBW_LAST=733, + XED_IFORMFL_KUNPCKDQ_FIRST=734, + XED_IFORMFL_KUNPCKDQ_LAST=734, + XED_IFORMFL_KUNPCKWD_FIRST=735, + XED_IFORMFL_KUNPCKWD_LAST=735, + XED_IFORMFL_KXNORB_FIRST=736, + XED_IFORMFL_KXNORB_LAST=736, + XED_IFORMFL_KXNORD_FIRST=737, + XED_IFORMFL_KXNORD_LAST=737, + XED_IFORMFL_KXNORQ_FIRST=738, + XED_IFORMFL_KXNORQ_LAST=738, + XED_IFORMFL_KXNORW_FIRST=739, + XED_IFORMFL_KXNORW_LAST=739, + XED_IFORMFL_KXORB_FIRST=740, + XED_IFORMFL_KXORB_LAST=740, + XED_IFORMFL_KXORD_FIRST=741, + XED_IFORMFL_KXORD_LAST=741, + XED_IFORMFL_KXORQ_FIRST=742, + XED_IFORMFL_KXORQ_LAST=742, + XED_IFORMFL_KXORW_FIRST=743, + XED_IFORMFL_KXORW_LAST=743, + XED_IFORMFL_LAHF_FIRST=744, + XED_IFORMFL_LAHF_LAST=744, + XED_IFORMFL_LAR_FIRST=745, + XED_IFORMFL_LAR_LAST=746, + XED_IFORMFL_LDDQU_FIRST=747, + XED_IFORMFL_LDDQU_LAST=747, + XED_IFORMFL_LDMXCSR_FIRST=748, + XED_IFORMFL_LDMXCSR_LAST=748, + XED_IFORMFL_LDS_FIRST=749, + XED_IFORMFL_LDS_LAST=749, + XED_IFORMFL_LEA_FIRST=750, + XED_IFORMFL_LEA_LAST=750, + XED_IFORMFL_LEAVE_FIRST=751, + XED_IFORMFL_LEAVE_LAST=751, + XED_IFORMFL_LES_FIRST=752, + XED_IFORMFL_LES_LAST=752, + XED_IFORMFL_LFENCE_FIRST=753, + XED_IFORMFL_LFENCE_LAST=753, + XED_IFORMFL_LFS_FIRST=754, + XED_IFORMFL_LFS_LAST=754, + XED_IFORMFL_LGDT_FIRST=755, + XED_IFORMFL_LGDT_LAST=756, + XED_IFORMFL_LGS_FIRST=757, + XED_IFORMFL_LGS_LAST=757, + XED_IFORMFL_LIDT_FIRST=758, + XED_IFORMFL_LIDT_LAST=759, + XED_IFORMFL_LLDT_FIRST=760, + XED_IFORMFL_LLDT_LAST=761, + XED_IFORMFL_LLWPCB_FIRST=762, + XED_IFORMFL_LLWPCB_LAST=762, + XED_IFORMFL_LMSW_FIRST=763, + XED_IFORMFL_LMSW_LAST=764, + XED_IFORMFL_LODSB_FIRST=765, + XED_IFORMFL_LODSB_LAST=765, + XED_IFORMFL_LODSD_FIRST=766, + XED_IFORMFL_LODSD_LAST=766, + XED_IFORMFL_LODSQ_FIRST=767, + XED_IFORMFL_LODSQ_LAST=767, + XED_IFORMFL_LODSW_FIRST=768, + XED_IFORMFL_LODSW_LAST=768, + XED_IFORMFL_LOOP_FIRST=769, + XED_IFORMFL_LOOP_LAST=769, + XED_IFORMFL_LOOPE_FIRST=770, + XED_IFORMFL_LOOPE_LAST=770, + XED_IFORMFL_LOOPNE_FIRST=771, + XED_IFORMFL_LOOPNE_LAST=771, + XED_IFORMFL_LSL_FIRST=772, + XED_IFORMFL_LSL_LAST=773, + XED_IFORMFL_LSS_FIRST=774, + XED_IFORMFL_LSS_LAST=774, + XED_IFORMFL_LTR_FIRST=775, + XED_IFORMFL_LTR_LAST=776, + XED_IFORMFL_LWPINS_FIRST=777, + XED_IFORMFL_LWPINS_LAST=778, + XED_IFORMFL_LWPVAL_FIRST=779, + XED_IFORMFL_LWPVAL_LAST=780, + XED_IFORMFL_LZCNT_FIRST=781, + XED_IFORMFL_LZCNT_LAST=782, + XED_IFORMFL_MASKMOVDQU_FIRST=783, + XED_IFORMFL_MASKMOVDQU_LAST=783, + XED_IFORMFL_MASKMOVQ_FIRST=784, + XED_IFORMFL_MASKMOVQ_LAST=784, + XED_IFORMFL_MAXPD_FIRST=785, + XED_IFORMFL_MAXPD_LAST=786, + XED_IFORMFL_MAXPS_FIRST=787, + XED_IFORMFL_MAXPS_LAST=788, + XED_IFORMFL_MAXSD_FIRST=789, + XED_IFORMFL_MAXSD_LAST=790, + XED_IFORMFL_MAXSS_FIRST=791, + XED_IFORMFL_MAXSS_LAST=792, + XED_IFORMFL_MFENCE_FIRST=793, + XED_IFORMFL_MFENCE_LAST=793, + XED_IFORMFL_MINPD_FIRST=794, + XED_IFORMFL_MINPD_LAST=795, + XED_IFORMFL_MINPS_FIRST=796, + XED_IFORMFL_MINPS_LAST=797, + XED_IFORMFL_MINSD_FIRST=798, + XED_IFORMFL_MINSD_LAST=799, + XED_IFORMFL_MINSS_FIRST=800, + XED_IFORMFL_MINSS_LAST=801, + XED_IFORMFL_MONITOR_FIRST=802, + XED_IFORMFL_MONITOR_LAST=802, + XED_IFORMFL_MOV_FIRST=803, + XED_IFORMFL_MOV_LAST=824, + XED_IFORMFL_MOVAPD_FIRST=825, + XED_IFORMFL_MOVAPD_LAST=828, + XED_IFORMFL_MOVAPS_FIRST=829, + XED_IFORMFL_MOVAPS_LAST=832, + XED_IFORMFL_MOVBE_FIRST=833, + XED_IFORMFL_MOVBE_LAST=834, + XED_IFORMFL_MOVD_FIRST=835, + XED_IFORMFL_MOVD_LAST=842, + XED_IFORMFL_MOVDDUP_FIRST=843, + XED_IFORMFL_MOVDDUP_LAST=844, + XED_IFORMFL_MOVDQ2Q_FIRST=845, + XED_IFORMFL_MOVDQ2Q_LAST=845, + XED_IFORMFL_MOVDQA_FIRST=846, + XED_IFORMFL_MOVDQA_LAST=849, + XED_IFORMFL_MOVDQU_FIRST=850, + XED_IFORMFL_MOVDQU_LAST=853, + XED_IFORMFL_MOVHLPS_FIRST=854, + XED_IFORMFL_MOVHLPS_LAST=854, + XED_IFORMFL_MOVHPD_FIRST=855, + XED_IFORMFL_MOVHPD_LAST=856, + XED_IFORMFL_MOVHPS_FIRST=857, + XED_IFORMFL_MOVHPS_LAST=858, + XED_IFORMFL_MOVLHPS_FIRST=859, + XED_IFORMFL_MOVLHPS_LAST=859, + XED_IFORMFL_MOVLPD_FIRST=860, + XED_IFORMFL_MOVLPD_LAST=861, + XED_IFORMFL_MOVLPS_FIRST=862, + XED_IFORMFL_MOVLPS_LAST=863, + XED_IFORMFL_MOVMSKPD_FIRST=864, + XED_IFORMFL_MOVMSKPD_LAST=864, + XED_IFORMFL_MOVMSKPS_FIRST=865, + XED_IFORMFL_MOVMSKPS_LAST=865, + XED_IFORMFL_MOVNTDQ_FIRST=866, + XED_IFORMFL_MOVNTDQ_LAST=866, + XED_IFORMFL_MOVNTDQA_FIRST=867, + XED_IFORMFL_MOVNTDQA_LAST=867, + XED_IFORMFL_MOVNTI_FIRST=868, + XED_IFORMFL_MOVNTI_LAST=869, + XED_IFORMFL_MOVNTPD_FIRST=870, + XED_IFORMFL_MOVNTPD_LAST=870, + XED_IFORMFL_MOVNTPS_FIRST=871, + XED_IFORMFL_MOVNTPS_LAST=871, + XED_IFORMFL_MOVNTQ_FIRST=872, + XED_IFORMFL_MOVNTQ_LAST=872, + XED_IFORMFL_MOVNTSD_FIRST=873, + XED_IFORMFL_MOVNTSD_LAST=873, + XED_IFORMFL_MOVNTSS_FIRST=874, + XED_IFORMFL_MOVNTSS_LAST=874, + XED_IFORMFL_MOVQ_FIRST=875, + XED_IFORMFL_MOVQ_LAST=890, + XED_IFORMFL_MOVQ2DQ_FIRST=891, + XED_IFORMFL_MOVQ2DQ_LAST=891, + XED_IFORMFL_MOVSB_FIRST=892, + XED_IFORMFL_MOVSB_LAST=892, + XED_IFORMFL_MOVSD_FIRST=893, + XED_IFORMFL_MOVSD_LAST=893, + XED_IFORMFL_MOVSD_XMM_FIRST=894, + XED_IFORMFL_MOVSD_XMM_LAST=897, + XED_IFORMFL_MOVSHDUP_FIRST=898, + XED_IFORMFL_MOVSHDUP_LAST=899, + XED_IFORMFL_MOVSLDUP_FIRST=900, + XED_IFORMFL_MOVSLDUP_LAST=901, + XED_IFORMFL_MOVSQ_FIRST=902, + XED_IFORMFL_MOVSQ_LAST=902, + XED_IFORMFL_MOVSS_FIRST=903, + XED_IFORMFL_MOVSS_LAST=906, + XED_IFORMFL_MOVSW_FIRST=907, + XED_IFORMFL_MOVSW_LAST=907, + XED_IFORMFL_MOVSX_FIRST=908, + XED_IFORMFL_MOVSX_LAST=911, + XED_IFORMFL_MOVSXD_FIRST=912, + XED_IFORMFL_MOVSXD_LAST=913, + XED_IFORMFL_MOVUPD_FIRST=914, + XED_IFORMFL_MOVUPD_LAST=917, + XED_IFORMFL_MOVUPS_FIRST=918, + XED_IFORMFL_MOVUPS_LAST=921, + XED_IFORMFL_MOVZX_FIRST=922, + XED_IFORMFL_MOVZX_LAST=925, + XED_IFORMFL_MOV_CR_FIRST=926, + XED_IFORMFL_MOV_CR_LAST=929, + XED_IFORMFL_MOV_DR_FIRST=930, + XED_IFORMFL_MOV_DR_LAST=933, + XED_IFORMFL_MPSADBW_FIRST=934, + XED_IFORMFL_MPSADBW_LAST=935, + XED_IFORMFL_MUL_FIRST=936, + XED_IFORMFL_MUL_LAST=939, + XED_IFORMFL_MULPD_FIRST=940, + XED_IFORMFL_MULPD_LAST=941, + XED_IFORMFL_MULPS_FIRST=942, + XED_IFORMFL_MULPS_LAST=943, + XED_IFORMFL_MULSD_FIRST=944, + XED_IFORMFL_MULSD_LAST=945, + XED_IFORMFL_MULSS_FIRST=946, + XED_IFORMFL_MULSS_LAST=947, + XED_IFORMFL_MULX_FIRST=948, + XED_IFORMFL_MULX_LAST=951, + XED_IFORMFL_MWAIT_FIRST=952, + XED_IFORMFL_MWAIT_LAST=952, + XED_IFORMFL_NEG_FIRST=953, + XED_IFORMFL_NEG_LAST=956, + XED_IFORMFL_NEG_LOCK_FIRST=957, + XED_IFORMFL_NEG_LOCK_LAST=958, + XED_IFORMFL_NOP_FIRST=959, + XED_IFORMFL_NOP_LAST=986, + XED_IFORMFL_NOT_FIRST=987, + XED_IFORMFL_NOT_LAST=990, + XED_IFORMFL_NOT_LOCK_FIRST=991, + XED_IFORMFL_NOT_LOCK_LAST=992, + XED_IFORMFL_OR_FIRST=993, + XED_IFORMFL_OR_LAST=1010, + XED_IFORMFL_ORPD_FIRST=1011, + XED_IFORMFL_ORPD_LAST=1012, + XED_IFORMFL_ORPS_FIRST=1013, + XED_IFORMFL_ORPS_LAST=1014, + XED_IFORMFL_OR_LOCK_FIRST=1015, + XED_IFORMFL_OR_LOCK_LAST=1020, + XED_IFORMFL_OUT_FIRST=1021, + XED_IFORMFL_OUT_LAST=1024, + XED_IFORMFL_OUTSB_FIRST=1025, + XED_IFORMFL_OUTSB_LAST=1025, + XED_IFORMFL_OUTSD_FIRST=1026, + XED_IFORMFL_OUTSD_LAST=1026, + XED_IFORMFL_OUTSW_FIRST=1027, + XED_IFORMFL_OUTSW_LAST=1027, + XED_IFORMFL_PABSB_FIRST=1028, + XED_IFORMFL_PABSB_LAST=1031, + XED_IFORMFL_PABSD_FIRST=1032, + XED_IFORMFL_PABSD_LAST=1035, + XED_IFORMFL_PABSW_FIRST=1036, + XED_IFORMFL_PABSW_LAST=1039, + XED_IFORMFL_PACKSSDW_FIRST=1040, + XED_IFORMFL_PACKSSDW_LAST=1043, + XED_IFORMFL_PACKSSWB_FIRST=1044, + XED_IFORMFL_PACKSSWB_LAST=1047, + XED_IFORMFL_PACKUSDW_FIRST=1048, + XED_IFORMFL_PACKUSDW_LAST=1049, + XED_IFORMFL_PACKUSWB_FIRST=1050, + XED_IFORMFL_PACKUSWB_LAST=1053, + XED_IFORMFL_PADDB_FIRST=1054, + XED_IFORMFL_PADDB_LAST=1057, + XED_IFORMFL_PADDD_FIRST=1058, + XED_IFORMFL_PADDD_LAST=1061, + XED_IFORMFL_PADDQ_FIRST=1062, + XED_IFORMFL_PADDQ_LAST=1065, + XED_IFORMFL_PADDSB_FIRST=1066, + XED_IFORMFL_PADDSB_LAST=1069, + XED_IFORMFL_PADDSW_FIRST=1070, + XED_IFORMFL_PADDSW_LAST=1073, + XED_IFORMFL_PADDUSB_FIRST=1074, + XED_IFORMFL_PADDUSB_LAST=1077, + XED_IFORMFL_PADDUSW_FIRST=1078, + XED_IFORMFL_PADDUSW_LAST=1081, + XED_IFORMFL_PADDW_FIRST=1082, + XED_IFORMFL_PADDW_LAST=1085, + XED_IFORMFL_PALIGNR_FIRST=1086, + XED_IFORMFL_PALIGNR_LAST=1089, + XED_IFORMFL_PAND_FIRST=1090, + XED_IFORMFL_PAND_LAST=1093, + XED_IFORMFL_PANDN_FIRST=1094, + XED_IFORMFL_PANDN_LAST=1097, + XED_IFORMFL_PAUSE_FIRST=1098, + XED_IFORMFL_PAUSE_LAST=1098, + XED_IFORMFL_PAVGB_FIRST=1099, + XED_IFORMFL_PAVGB_LAST=1102, + XED_IFORMFL_PAVGUSB_FIRST=1103, + XED_IFORMFL_PAVGUSB_LAST=1104, + XED_IFORMFL_PAVGW_FIRST=1105, + XED_IFORMFL_PAVGW_LAST=1108, + XED_IFORMFL_PBLENDVB_FIRST=1109, + XED_IFORMFL_PBLENDVB_LAST=1110, + XED_IFORMFL_PBLENDW_FIRST=1111, + XED_IFORMFL_PBLENDW_LAST=1112, + XED_IFORMFL_PCLMULQDQ_FIRST=1113, + XED_IFORMFL_PCLMULQDQ_LAST=1114, + XED_IFORMFL_PCMPEQB_FIRST=1115, + XED_IFORMFL_PCMPEQB_LAST=1118, + XED_IFORMFL_PCMPEQD_FIRST=1119, + XED_IFORMFL_PCMPEQD_LAST=1122, + XED_IFORMFL_PCMPEQQ_FIRST=1123, + XED_IFORMFL_PCMPEQQ_LAST=1124, + XED_IFORMFL_PCMPEQW_FIRST=1125, + XED_IFORMFL_PCMPEQW_LAST=1128, + XED_IFORMFL_PCMPESTRI_FIRST=1129, + XED_IFORMFL_PCMPESTRI_LAST=1130, + XED_IFORMFL_PCMPESTRM_FIRST=1131, + XED_IFORMFL_PCMPESTRM_LAST=1132, + XED_IFORMFL_PCMPGTB_FIRST=1133, + XED_IFORMFL_PCMPGTB_LAST=1136, + XED_IFORMFL_PCMPGTD_FIRST=1137, + XED_IFORMFL_PCMPGTD_LAST=1140, + XED_IFORMFL_PCMPGTQ_FIRST=1141, + XED_IFORMFL_PCMPGTQ_LAST=1142, + XED_IFORMFL_PCMPGTW_FIRST=1143, + XED_IFORMFL_PCMPGTW_LAST=1146, + XED_IFORMFL_PCMPISTRI_FIRST=1147, + XED_IFORMFL_PCMPISTRI_LAST=1148, + XED_IFORMFL_PCMPISTRM_FIRST=1149, + XED_IFORMFL_PCMPISTRM_LAST=1150, + XED_IFORMFL_PCOMMIT_FIRST=1151, + XED_IFORMFL_PCOMMIT_LAST=1151, + XED_IFORMFL_PDEP_FIRST=1152, + XED_IFORMFL_PDEP_LAST=1155, + XED_IFORMFL_PEXT_FIRST=1156, + XED_IFORMFL_PEXT_LAST=1159, + XED_IFORMFL_PEXTRB_FIRST=1160, + XED_IFORMFL_PEXTRB_LAST=1161, + XED_IFORMFL_PEXTRD_FIRST=1162, + XED_IFORMFL_PEXTRD_LAST=1163, + XED_IFORMFL_PEXTRQ_FIRST=1164, + XED_IFORMFL_PEXTRQ_LAST=1165, + XED_IFORMFL_PEXTRW_FIRST=1166, + XED_IFORMFL_PEXTRW_LAST=1167, + XED_IFORMFL_PEXTRW_SSE4_FIRST=1168, + XED_IFORMFL_PEXTRW_SSE4_LAST=1169, + XED_IFORMFL_PF2ID_FIRST=1170, + XED_IFORMFL_PF2ID_LAST=1171, + XED_IFORMFL_PF2IW_FIRST=1172, + XED_IFORMFL_PF2IW_LAST=1173, + XED_IFORMFL_PFACC_FIRST=1174, + XED_IFORMFL_PFACC_LAST=1175, + XED_IFORMFL_PFADD_FIRST=1176, + XED_IFORMFL_PFADD_LAST=1177, + XED_IFORMFL_PFCMPEQ_FIRST=1178, + XED_IFORMFL_PFCMPEQ_LAST=1179, + XED_IFORMFL_PFCMPGE_FIRST=1180, + XED_IFORMFL_PFCMPGE_LAST=1181, + XED_IFORMFL_PFCMPGT_FIRST=1182, + XED_IFORMFL_PFCMPGT_LAST=1183, + XED_IFORMFL_PFCPIT1_FIRST=1184, + XED_IFORMFL_PFCPIT1_LAST=1185, + XED_IFORMFL_PFMAX_FIRST=1186, + XED_IFORMFL_PFMAX_LAST=1187, + XED_IFORMFL_PFMIN_FIRST=1188, + XED_IFORMFL_PFMIN_LAST=1189, + XED_IFORMFL_PFMUL_FIRST=1190, + XED_IFORMFL_PFMUL_LAST=1191, + XED_IFORMFL_PFNACC_FIRST=1192, + XED_IFORMFL_PFNACC_LAST=1193, + XED_IFORMFL_PFPNACC_FIRST=1194, + XED_IFORMFL_PFPNACC_LAST=1195, + XED_IFORMFL_PFRCP_FIRST=1196, + XED_IFORMFL_PFRCP_LAST=1197, + XED_IFORMFL_PFRCPIT2_FIRST=1198, + XED_IFORMFL_PFRCPIT2_LAST=1199, + XED_IFORMFL_PFRSQIT1_FIRST=1200, + XED_IFORMFL_PFRSQIT1_LAST=1201, + XED_IFORMFL_PFSQRT_FIRST=1202, + XED_IFORMFL_PFSQRT_LAST=1203, + XED_IFORMFL_PFSUB_FIRST=1204, + XED_IFORMFL_PFSUB_LAST=1205, + XED_IFORMFL_PFSUBR_FIRST=1206, + XED_IFORMFL_PFSUBR_LAST=1207, + XED_IFORMFL_PHADDD_FIRST=1208, + XED_IFORMFL_PHADDD_LAST=1211, + XED_IFORMFL_PHADDSW_FIRST=1212, + XED_IFORMFL_PHADDSW_LAST=1215, + XED_IFORMFL_PHADDW_FIRST=1216, + XED_IFORMFL_PHADDW_LAST=1219, + XED_IFORMFL_PHMINPOSUW_FIRST=1220, + XED_IFORMFL_PHMINPOSUW_LAST=1221, + XED_IFORMFL_PHSUBD_FIRST=1222, + XED_IFORMFL_PHSUBD_LAST=1225, + XED_IFORMFL_PHSUBSW_FIRST=1226, + XED_IFORMFL_PHSUBSW_LAST=1229, + XED_IFORMFL_PHSUBW_FIRST=1230, + XED_IFORMFL_PHSUBW_LAST=1233, + XED_IFORMFL_PI2FD_FIRST=1234, + XED_IFORMFL_PI2FD_LAST=1235, + XED_IFORMFL_PI2FW_FIRST=1236, + XED_IFORMFL_PI2FW_LAST=1237, + XED_IFORMFL_PINSRB_FIRST=1238, + XED_IFORMFL_PINSRB_LAST=1239, + XED_IFORMFL_PINSRD_FIRST=1240, + XED_IFORMFL_PINSRD_LAST=1241, + XED_IFORMFL_PINSRQ_FIRST=1242, + XED_IFORMFL_PINSRQ_LAST=1243, + XED_IFORMFL_PINSRW_FIRST=1244, + XED_IFORMFL_PINSRW_LAST=1247, + XED_IFORMFL_PMADDUBSW_FIRST=1248, + XED_IFORMFL_PMADDUBSW_LAST=1251, + XED_IFORMFL_PMADDWD_FIRST=1252, + XED_IFORMFL_PMADDWD_LAST=1255, + XED_IFORMFL_PMAXSB_FIRST=1256, + XED_IFORMFL_PMAXSB_LAST=1257, + XED_IFORMFL_PMAXSD_FIRST=1258, + XED_IFORMFL_PMAXSD_LAST=1259, + XED_IFORMFL_PMAXSW_FIRST=1260, + XED_IFORMFL_PMAXSW_LAST=1263, + XED_IFORMFL_PMAXUB_FIRST=1264, + XED_IFORMFL_PMAXUB_LAST=1267, + XED_IFORMFL_PMAXUD_FIRST=1268, + XED_IFORMFL_PMAXUD_LAST=1269, + XED_IFORMFL_PMAXUW_FIRST=1270, + XED_IFORMFL_PMAXUW_LAST=1271, + XED_IFORMFL_PMINSB_FIRST=1272, + XED_IFORMFL_PMINSB_LAST=1273, + XED_IFORMFL_PMINSD_FIRST=1274, + XED_IFORMFL_PMINSD_LAST=1275, + XED_IFORMFL_PMINSW_FIRST=1276, + XED_IFORMFL_PMINSW_LAST=1279, + XED_IFORMFL_PMINUB_FIRST=1280, + XED_IFORMFL_PMINUB_LAST=1283, + XED_IFORMFL_PMINUD_FIRST=1284, + XED_IFORMFL_PMINUD_LAST=1285, + XED_IFORMFL_PMINUW_FIRST=1286, + XED_IFORMFL_PMINUW_LAST=1287, + XED_IFORMFL_PMOVMSKB_FIRST=1288, + XED_IFORMFL_PMOVMSKB_LAST=1289, + XED_IFORMFL_PMOVSXBD_FIRST=1290, + XED_IFORMFL_PMOVSXBD_LAST=1291, + XED_IFORMFL_PMOVSXBQ_FIRST=1292, + XED_IFORMFL_PMOVSXBQ_LAST=1293, + XED_IFORMFL_PMOVSXBW_FIRST=1294, + XED_IFORMFL_PMOVSXBW_LAST=1295, + XED_IFORMFL_PMOVSXDQ_FIRST=1296, + XED_IFORMFL_PMOVSXDQ_LAST=1297, + XED_IFORMFL_PMOVSXWD_FIRST=1298, + XED_IFORMFL_PMOVSXWD_LAST=1299, + XED_IFORMFL_PMOVSXWQ_FIRST=1300, + XED_IFORMFL_PMOVSXWQ_LAST=1301, + XED_IFORMFL_PMOVZXBD_FIRST=1302, + XED_IFORMFL_PMOVZXBD_LAST=1303, + XED_IFORMFL_PMOVZXBQ_FIRST=1304, + XED_IFORMFL_PMOVZXBQ_LAST=1305, + XED_IFORMFL_PMOVZXBW_FIRST=1306, + XED_IFORMFL_PMOVZXBW_LAST=1307, + XED_IFORMFL_PMOVZXDQ_FIRST=1308, + XED_IFORMFL_PMOVZXDQ_LAST=1309, + XED_IFORMFL_PMOVZXWD_FIRST=1310, + XED_IFORMFL_PMOVZXWD_LAST=1311, + XED_IFORMFL_PMOVZXWQ_FIRST=1312, + XED_IFORMFL_PMOVZXWQ_LAST=1313, + XED_IFORMFL_PMULDQ_FIRST=1314, + XED_IFORMFL_PMULDQ_LAST=1315, + XED_IFORMFL_PMULHRSW_FIRST=1316, + XED_IFORMFL_PMULHRSW_LAST=1319, + XED_IFORMFL_PMULHRW_FIRST=1320, + XED_IFORMFL_PMULHRW_LAST=1321, + XED_IFORMFL_PMULHUW_FIRST=1322, + XED_IFORMFL_PMULHUW_LAST=1325, + XED_IFORMFL_PMULHW_FIRST=1326, + XED_IFORMFL_PMULHW_LAST=1329, + XED_IFORMFL_PMULLD_FIRST=1330, + XED_IFORMFL_PMULLD_LAST=1331, + XED_IFORMFL_PMULLW_FIRST=1332, + XED_IFORMFL_PMULLW_LAST=1335, + XED_IFORMFL_PMULUDQ_FIRST=1336, + XED_IFORMFL_PMULUDQ_LAST=1339, + XED_IFORMFL_POP_FIRST=1340, + XED_IFORMFL_POP_LAST=1347, + XED_IFORMFL_POPA_FIRST=1348, + XED_IFORMFL_POPA_LAST=1348, + XED_IFORMFL_POPAD_FIRST=1349, + XED_IFORMFL_POPAD_LAST=1349, + XED_IFORMFL_POPCNT_FIRST=1350, + XED_IFORMFL_POPCNT_LAST=1351, + XED_IFORMFL_POPF_FIRST=1352, + XED_IFORMFL_POPF_LAST=1352, + XED_IFORMFL_POPFD_FIRST=1353, + XED_IFORMFL_POPFD_LAST=1353, + XED_IFORMFL_POPFQ_FIRST=1354, + XED_IFORMFL_POPFQ_LAST=1354, + XED_IFORMFL_POR_FIRST=1355, + XED_IFORMFL_POR_LAST=1358, + XED_IFORMFL_PREFETCHNTA_FIRST=1359, + XED_IFORMFL_PREFETCHNTA_LAST=1359, + XED_IFORMFL_PREFETCHT0_FIRST=1360, + XED_IFORMFL_PREFETCHT0_LAST=1360, + XED_IFORMFL_PREFETCHT1_FIRST=1361, + XED_IFORMFL_PREFETCHT1_LAST=1361, + XED_IFORMFL_PREFETCHT2_FIRST=1362, + XED_IFORMFL_PREFETCHT2_LAST=1362, + XED_IFORMFL_PREFETCHW_FIRST=1363, + XED_IFORMFL_PREFETCHW_LAST=1364, + XED_IFORMFL_PREFETCHWT1_FIRST=1365, + XED_IFORMFL_PREFETCHWT1_LAST=1365, + XED_IFORMFL_PREFETCH_EXCLUSIVE_FIRST=1366, + XED_IFORMFL_PREFETCH_EXCLUSIVE_LAST=1366, + XED_IFORMFL_PREFETCH_RESERVED_FIRST=1367, + XED_IFORMFL_PREFETCH_RESERVED_LAST=1370, + XED_IFORMFL_PSADBW_FIRST=1371, + XED_IFORMFL_PSADBW_LAST=1374, + XED_IFORMFL_PSHUFB_FIRST=1375, + XED_IFORMFL_PSHUFB_LAST=1378, + XED_IFORMFL_PSHUFD_FIRST=1379, + XED_IFORMFL_PSHUFD_LAST=1380, + XED_IFORMFL_PSHUFHW_FIRST=1381, + XED_IFORMFL_PSHUFHW_LAST=1382, + XED_IFORMFL_PSHUFLW_FIRST=1383, + XED_IFORMFL_PSHUFLW_LAST=1384, + XED_IFORMFL_PSHUFW_FIRST=1385, + XED_IFORMFL_PSHUFW_LAST=1386, + XED_IFORMFL_PSIGNB_FIRST=1387, + XED_IFORMFL_PSIGNB_LAST=1390, + XED_IFORMFL_PSIGND_FIRST=1391, + XED_IFORMFL_PSIGND_LAST=1394, + XED_IFORMFL_PSIGNW_FIRST=1395, + XED_IFORMFL_PSIGNW_LAST=1398, + XED_IFORMFL_PSLLD_FIRST=1399, + XED_IFORMFL_PSLLD_LAST=1404, + XED_IFORMFL_PSLLDQ_FIRST=1405, + XED_IFORMFL_PSLLDQ_LAST=1405, + XED_IFORMFL_PSLLQ_FIRST=1406, + XED_IFORMFL_PSLLQ_LAST=1411, + XED_IFORMFL_PSLLW_FIRST=1412, + XED_IFORMFL_PSLLW_LAST=1417, + XED_IFORMFL_PSRAD_FIRST=1418, + XED_IFORMFL_PSRAD_LAST=1423, + XED_IFORMFL_PSRAW_FIRST=1424, + XED_IFORMFL_PSRAW_LAST=1429, + XED_IFORMFL_PSRLD_FIRST=1430, + XED_IFORMFL_PSRLD_LAST=1435, + XED_IFORMFL_PSRLDQ_FIRST=1436, + XED_IFORMFL_PSRLDQ_LAST=1436, + XED_IFORMFL_PSRLQ_FIRST=1437, + XED_IFORMFL_PSRLQ_LAST=1442, + XED_IFORMFL_PSRLW_FIRST=1443, + XED_IFORMFL_PSRLW_LAST=1448, + XED_IFORMFL_PSUBB_FIRST=1449, + XED_IFORMFL_PSUBB_LAST=1452, + XED_IFORMFL_PSUBD_FIRST=1453, + XED_IFORMFL_PSUBD_LAST=1456, + XED_IFORMFL_PSUBQ_FIRST=1457, + XED_IFORMFL_PSUBQ_LAST=1460, + XED_IFORMFL_PSUBSB_FIRST=1461, + XED_IFORMFL_PSUBSB_LAST=1464, + XED_IFORMFL_PSUBSW_FIRST=1465, + XED_IFORMFL_PSUBSW_LAST=1468, + XED_IFORMFL_PSUBUSB_FIRST=1469, + XED_IFORMFL_PSUBUSB_LAST=1472, + XED_IFORMFL_PSUBUSW_FIRST=1473, + XED_IFORMFL_PSUBUSW_LAST=1476, + XED_IFORMFL_PSUBW_FIRST=1477, + XED_IFORMFL_PSUBW_LAST=1480, + XED_IFORMFL_PSWAPD_FIRST=1481, + XED_IFORMFL_PSWAPD_LAST=1482, + XED_IFORMFL_PTEST_FIRST=1483, + XED_IFORMFL_PTEST_LAST=1484, + XED_IFORMFL_PUNPCKHBW_FIRST=1485, + XED_IFORMFL_PUNPCKHBW_LAST=1488, + XED_IFORMFL_PUNPCKHDQ_FIRST=1489, + XED_IFORMFL_PUNPCKHDQ_LAST=1492, + XED_IFORMFL_PUNPCKHQDQ_FIRST=1493, + XED_IFORMFL_PUNPCKHQDQ_LAST=1494, + XED_IFORMFL_PUNPCKHWD_FIRST=1495, + XED_IFORMFL_PUNPCKHWD_LAST=1498, + XED_IFORMFL_PUNPCKLBW_FIRST=1499, + XED_IFORMFL_PUNPCKLBW_LAST=1502, + XED_IFORMFL_PUNPCKLDQ_FIRST=1503, + XED_IFORMFL_PUNPCKLDQ_LAST=1506, + XED_IFORMFL_PUNPCKLQDQ_FIRST=1507, + XED_IFORMFL_PUNPCKLQDQ_LAST=1508, + XED_IFORMFL_PUNPCKLWD_FIRST=1509, + XED_IFORMFL_PUNPCKLWD_LAST=1512, + XED_IFORMFL_PUSH_FIRST=1513, + XED_IFORMFL_PUSH_LAST=1523, + XED_IFORMFL_PUSHA_FIRST=1524, + XED_IFORMFL_PUSHA_LAST=1524, + XED_IFORMFL_PUSHAD_FIRST=1525, + XED_IFORMFL_PUSHAD_LAST=1525, + XED_IFORMFL_PUSHF_FIRST=1526, + XED_IFORMFL_PUSHF_LAST=1526, + XED_IFORMFL_PUSHFD_FIRST=1527, + XED_IFORMFL_PUSHFD_LAST=1527, + XED_IFORMFL_PUSHFQ_FIRST=1528, + XED_IFORMFL_PUSHFQ_LAST=1528, + XED_IFORMFL_PXOR_FIRST=1529, + XED_IFORMFL_PXOR_LAST=1532, + XED_IFORMFL_RCL_FIRST=1533, + XED_IFORMFL_RCL_LAST=1544, + XED_IFORMFL_RCPPS_FIRST=1545, + XED_IFORMFL_RCPPS_LAST=1546, + XED_IFORMFL_RCPSS_FIRST=1547, + XED_IFORMFL_RCPSS_LAST=1548, + XED_IFORMFL_RCR_FIRST=1549, + XED_IFORMFL_RCR_LAST=1560, + XED_IFORMFL_RDFSBASE_FIRST=1561, + XED_IFORMFL_RDFSBASE_LAST=1561, + XED_IFORMFL_RDGSBASE_FIRST=1562, + XED_IFORMFL_RDGSBASE_LAST=1562, + XED_IFORMFL_RDMSR_FIRST=1563, + XED_IFORMFL_RDMSR_LAST=1563, + XED_IFORMFL_RDPMC_FIRST=1564, + XED_IFORMFL_RDPMC_LAST=1564, + XED_IFORMFL_RDRAND_FIRST=1565, + XED_IFORMFL_RDRAND_LAST=1565, + XED_IFORMFL_RDSEED_FIRST=1566, + XED_IFORMFL_RDSEED_LAST=1566, + XED_IFORMFL_RDTSC_FIRST=1567, + XED_IFORMFL_RDTSC_LAST=1567, + XED_IFORMFL_RDTSCP_FIRST=1568, + XED_IFORMFL_RDTSCP_LAST=1568, + XED_IFORMFL_REPE_CMPSB_FIRST=1569, + XED_IFORMFL_REPE_CMPSB_LAST=1569, + XED_IFORMFL_REPE_CMPSD_FIRST=1570, + XED_IFORMFL_REPE_CMPSD_LAST=1570, + XED_IFORMFL_REPE_CMPSQ_FIRST=1571, + XED_IFORMFL_REPE_CMPSQ_LAST=1571, + XED_IFORMFL_REPE_CMPSW_FIRST=1572, + XED_IFORMFL_REPE_CMPSW_LAST=1572, + XED_IFORMFL_REPE_SCASB_FIRST=1573, + XED_IFORMFL_REPE_SCASB_LAST=1573, + XED_IFORMFL_REPE_SCASD_FIRST=1574, + XED_IFORMFL_REPE_SCASD_LAST=1574, + XED_IFORMFL_REPE_SCASQ_FIRST=1575, + XED_IFORMFL_REPE_SCASQ_LAST=1575, + XED_IFORMFL_REPE_SCASW_FIRST=1576, + XED_IFORMFL_REPE_SCASW_LAST=1576, + XED_IFORMFL_REPNE_CMPSB_FIRST=1577, + XED_IFORMFL_REPNE_CMPSB_LAST=1577, + XED_IFORMFL_REPNE_CMPSD_FIRST=1578, + XED_IFORMFL_REPNE_CMPSD_LAST=1578, + XED_IFORMFL_REPNE_CMPSQ_FIRST=1579, + XED_IFORMFL_REPNE_CMPSQ_LAST=1579, + XED_IFORMFL_REPNE_CMPSW_FIRST=1580, + XED_IFORMFL_REPNE_CMPSW_LAST=1580, + XED_IFORMFL_REPNE_SCASB_FIRST=1581, + XED_IFORMFL_REPNE_SCASB_LAST=1581, + XED_IFORMFL_REPNE_SCASD_FIRST=1582, + XED_IFORMFL_REPNE_SCASD_LAST=1582, + XED_IFORMFL_REPNE_SCASQ_FIRST=1583, + XED_IFORMFL_REPNE_SCASQ_LAST=1583, + XED_IFORMFL_REPNE_SCASW_FIRST=1584, + XED_IFORMFL_REPNE_SCASW_LAST=1584, + XED_IFORMFL_REP_INSB_FIRST=1585, + XED_IFORMFL_REP_INSB_LAST=1585, + XED_IFORMFL_REP_INSD_FIRST=1586, + XED_IFORMFL_REP_INSD_LAST=1586, + XED_IFORMFL_REP_INSW_FIRST=1587, + XED_IFORMFL_REP_INSW_LAST=1587, + XED_IFORMFL_REP_LODSB_FIRST=1588, + XED_IFORMFL_REP_LODSB_LAST=1588, + XED_IFORMFL_REP_LODSD_FIRST=1589, + XED_IFORMFL_REP_LODSD_LAST=1589, + XED_IFORMFL_REP_LODSQ_FIRST=1590, + XED_IFORMFL_REP_LODSQ_LAST=1590, + XED_IFORMFL_REP_LODSW_FIRST=1591, + XED_IFORMFL_REP_LODSW_LAST=1591, + XED_IFORMFL_REP_MOVSB_FIRST=1592, + XED_IFORMFL_REP_MOVSB_LAST=1592, + XED_IFORMFL_REP_MOVSD_FIRST=1593, + XED_IFORMFL_REP_MOVSD_LAST=1593, + XED_IFORMFL_REP_MOVSQ_FIRST=1594, + XED_IFORMFL_REP_MOVSQ_LAST=1594, + XED_IFORMFL_REP_MOVSW_FIRST=1595, + XED_IFORMFL_REP_MOVSW_LAST=1595, + XED_IFORMFL_REP_OUTSB_FIRST=1596, + XED_IFORMFL_REP_OUTSB_LAST=1596, + XED_IFORMFL_REP_OUTSD_FIRST=1597, + XED_IFORMFL_REP_OUTSD_LAST=1597, + XED_IFORMFL_REP_OUTSW_FIRST=1598, + XED_IFORMFL_REP_OUTSW_LAST=1598, + XED_IFORMFL_REP_STOSB_FIRST=1599, + XED_IFORMFL_REP_STOSB_LAST=1599, + XED_IFORMFL_REP_STOSD_FIRST=1600, + XED_IFORMFL_REP_STOSD_LAST=1600, + XED_IFORMFL_REP_STOSQ_FIRST=1601, + XED_IFORMFL_REP_STOSQ_LAST=1601, + XED_IFORMFL_REP_STOSW_FIRST=1602, + XED_IFORMFL_REP_STOSW_LAST=1602, + XED_IFORMFL_RET_FAR_FIRST=1603, + XED_IFORMFL_RET_FAR_LAST=1604, + XED_IFORMFL_RET_NEAR_FIRST=1605, + XED_IFORMFL_RET_NEAR_LAST=1606, + XED_IFORMFL_ROL_FIRST=1607, + XED_IFORMFL_ROL_LAST=1618, + XED_IFORMFL_ROR_FIRST=1619, + XED_IFORMFL_ROR_LAST=1630, + XED_IFORMFL_RORX_FIRST=1631, + XED_IFORMFL_RORX_LAST=1634, + XED_IFORMFL_ROUNDPD_FIRST=1635, + XED_IFORMFL_ROUNDPD_LAST=1636, + XED_IFORMFL_ROUNDPS_FIRST=1637, + XED_IFORMFL_ROUNDPS_LAST=1638, + XED_IFORMFL_ROUNDSD_FIRST=1639, + XED_IFORMFL_ROUNDSD_LAST=1640, + XED_IFORMFL_ROUNDSS_FIRST=1641, + XED_IFORMFL_ROUNDSS_LAST=1642, + XED_IFORMFL_RSM_FIRST=1643, + XED_IFORMFL_RSM_LAST=1643, + XED_IFORMFL_RSQRTPS_FIRST=1644, + XED_IFORMFL_RSQRTPS_LAST=1645, + XED_IFORMFL_RSQRTSS_FIRST=1646, + XED_IFORMFL_RSQRTSS_LAST=1647, + XED_IFORMFL_SAHF_FIRST=1648, + XED_IFORMFL_SAHF_LAST=1648, + XED_IFORMFL_SALC_FIRST=1649, + XED_IFORMFL_SALC_LAST=1649, + XED_IFORMFL_SAR_FIRST=1650, + XED_IFORMFL_SAR_LAST=1661, + XED_IFORMFL_SARX_FIRST=1662, + XED_IFORMFL_SARX_LAST=1665, + XED_IFORMFL_SBB_FIRST=1666, + XED_IFORMFL_SBB_LAST=1683, + XED_IFORMFL_SBB_LOCK_FIRST=1684, + XED_IFORMFL_SBB_LOCK_LAST=1689, + XED_IFORMFL_SCASB_FIRST=1690, + XED_IFORMFL_SCASB_LAST=1690, + XED_IFORMFL_SCASD_FIRST=1691, + XED_IFORMFL_SCASD_LAST=1691, + XED_IFORMFL_SCASQ_FIRST=1692, + XED_IFORMFL_SCASQ_LAST=1692, + XED_IFORMFL_SCASW_FIRST=1693, + XED_IFORMFL_SCASW_LAST=1693, + XED_IFORMFL_SETB_FIRST=1694, + XED_IFORMFL_SETB_LAST=1695, + XED_IFORMFL_SETBE_FIRST=1696, + XED_IFORMFL_SETBE_LAST=1697, + XED_IFORMFL_SETL_FIRST=1698, + XED_IFORMFL_SETL_LAST=1699, + XED_IFORMFL_SETLE_FIRST=1700, + XED_IFORMFL_SETLE_LAST=1701, + XED_IFORMFL_SETNB_FIRST=1702, + XED_IFORMFL_SETNB_LAST=1703, + XED_IFORMFL_SETNBE_FIRST=1704, + XED_IFORMFL_SETNBE_LAST=1705, + XED_IFORMFL_SETNL_FIRST=1706, + XED_IFORMFL_SETNL_LAST=1707, + XED_IFORMFL_SETNLE_FIRST=1708, + XED_IFORMFL_SETNLE_LAST=1709, + XED_IFORMFL_SETNO_FIRST=1710, + XED_IFORMFL_SETNO_LAST=1711, + XED_IFORMFL_SETNP_FIRST=1712, + XED_IFORMFL_SETNP_LAST=1713, + XED_IFORMFL_SETNS_FIRST=1714, + XED_IFORMFL_SETNS_LAST=1715, + XED_IFORMFL_SETNZ_FIRST=1716, + XED_IFORMFL_SETNZ_LAST=1717, + XED_IFORMFL_SETO_FIRST=1718, + XED_IFORMFL_SETO_LAST=1719, + XED_IFORMFL_SETP_FIRST=1720, + XED_IFORMFL_SETP_LAST=1721, + XED_IFORMFL_SETS_FIRST=1722, + XED_IFORMFL_SETS_LAST=1723, + XED_IFORMFL_SETZ_FIRST=1724, + XED_IFORMFL_SETZ_LAST=1725, + XED_IFORMFL_SFENCE_FIRST=1726, + XED_IFORMFL_SFENCE_LAST=1726, + XED_IFORMFL_SGDT_FIRST=1727, + XED_IFORMFL_SGDT_LAST=1728, + XED_IFORMFL_SHA1MSG1_FIRST=1729, + XED_IFORMFL_SHA1MSG1_LAST=1730, + XED_IFORMFL_SHA1MSG2_FIRST=1731, + XED_IFORMFL_SHA1MSG2_LAST=1732, + XED_IFORMFL_SHA1NEXTE_FIRST=1733, + XED_IFORMFL_SHA1NEXTE_LAST=1734, + XED_IFORMFL_SHA1RNDS4_FIRST=1735, + XED_IFORMFL_SHA1RNDS4_LAST=1736, + XED_IFORMFL_SHA256MSG1_FIRST=1737, + XED_IFORMFL_SHA256MSG1_LAST=1738, + XED_IFORMFL_SHA256MSG2_FIRST=1739, + XED_IFORMFL_SHA256MSG2_LAST=1740, + XED_IFORMFL_SHA256RNDS2_FIRST=1741, + XED_IFORMFL_SHA256RNDS2_LAST=1742, + XED_IFORMFL_SHL_FIRST=1743, + XED_IFORMFL_SHL_LAST=1766, + XED_IFORMFL_SHLD_FIRST=1767, + XED_IFORMFL_SHLD_LAST=1770, + XED_IFORMFL_SHLX_FIRST=1771, + XED_IFORMFL_SHLX_LAST=1774, + XED_IFORMFL_SHR_FIRST=1775, + XED_IFORMFL_SHR_LAST=1786, + XED_IFORMFL_SHRD_FIRST=1787, + XED_IFORMFL_SHRD_LAST=1790, + XED_IFORMFL_SHRX_FIRST=1791, + XED_IFORMFL_SHRX_LAST=1794, + XED_IFORMFL_SHUFPD_FIRST=1795, + XED_IFORMFL_SHUFPD_LAST=1796, + XED_IFORMFL_SHUFPS_FIRST=1797, + XED_IFORMFL_SHUFPS_LAST=1798, + XED_IFORMFL_SIDT_FIRST=1799, + XED_IFORMFL_SIDT_LAST=1800, + XED_IFORMFL_SKINIT_FIRST=1801, + XED_IFORMFL_SKINIT_LAST=1801, + XED_IFORMFL_SLDT_FIRST=1802, + XED_IFORMFL_SLDT_LAST=1803, + XED_IFORMFL_SLWPCB_FIRST=1804, + XED_IFORMFL_SLWPCB_LAST=1804, + XED_IFORMFL_SMSW_FIRST=1805, + XED_IFORMFL_SMSW_LAST=1806, + XED_IFORMFL_SQRTPD_FIRST=1807, + XED_IFORMFL_SQRTPD_LAST=1808, + XED_IFORMFL_SQRTPS_FIRST=1809, + XED_IFORMFL_SQRTPS_LAST=1810, + XED_IFORMFL_SQRTSD_FIRST=1811, + XED_IFORMFL_SQRTSD_LAST=1812, + XED_IFORMFL_SQRTSS_FIRST=1813, + XED_IFORMFL_SQRTSS_LAST=1814, + XED_IFORMFL_STAC_FIRST=1815, + XED_IFORMFL_STAC_LAST=1815, + XED_IFORMFL_STC_FIRST=1816, + XED_IFORMFL_STC_LAST=1816, + XED_IFORMFL_STD_FIRST=1817, + XED_IFORMFL_STD_LAST=1817, + XED_IFORMFL_STGI_FIRST=1818, + XED_IFORMFL_STGI_LAST=1818, + XED_IFORMFL_STI_FIRST=1819, + XED_IFORMFL_STI_LAST=1819, + XED_IFORMFL_STMXCSR_FIRST=1820, + XED_IFORMFL_STMXCSR_LAST=1820, + XED_IFORMFL_STOSB_FIRST=1821, + XED_IFORMFL_STOSB_LAST=1821, + XED_IFORMFL_STOSD_FIRST=1822, + XED_IFORMFL_STOSD_LAST=1822, + XED_IFORMFL_STOSQ_FIRST=1823, + XED_IFORMFL_STOSQ_LAST=1823, + XED_IFORMFL_STOSW_FIRST=1824, + XED_IFORMFL_STOSW_LAST=1824, + XED_IFORMFL_STR_FIRST=1825, + XED_IFORMFL_STR_LAST=1826, + XED_IFORMFL_SUB_FIRST=1827, + XED_IFORMFL_SUB_LAST=1844, + XED_IFORMFL_SUBPD_FIRST=1845, + XED_IFORMFL_SUBPD_LAST=1846, + XED_IFORMFL_SUBPS_FIRST=1847, + XED_IFORMFL_SUBPS_LAST=1848, + XED_IFORMFL_SUBSD_FIRST=1849, + XED_IFORMFL_SUBSD_LAST=1850, + XED_IFORMFL_SUBSS_FIRST=1851, + XED_IFORMFL_SUBSS_LAST=1852, + XED_IFORMFL_SUB_LOCK_FIRST=1853, + XED_IFORMFL_SUB_LOCK_LAST=1858, + XED_IFORMFL_SWAPGS_FIRST=1859, + XED_IFORMFL_SWAPGS_LAST=1859, + XED_IFORMFL_SYSCALL_FIRST=1860, + XED_IFORMFL_SYSCALL_LAST=1860, + XED_IFORMFL_SYSCALL_AMD_FIRST=1861, + XED_IFORMFL_SYSCALL_AMD_LAST=1861, + XED_IFORMFL_SYSENTER_FIRST=1862, + XED_IFORMFL_SYSENTER_LAST=1862, + XED_IFORMFL_SYSEXIT_FIRST=1863, + XED_IFORMFL_SYSEXIT_LAST=1863, + XED_IFORMFL_SYSRET_FIRST=1864, + XED_IFORMFL_SYSRET_LAST=1864, + XED_IFORMFL_SYSRET_AMD_FIRST=1865, + XED_IFORMFL_SYSRET_AMD_LAST=1865, + XED_IFORMFL_T1MSKC_FIRST=1866, + XED_IFORMFL_T1MSKC_LAST=1867, + XED_IFORMFL_TEST_FIRST=1868, + XED_IFORMFL_TEST_LAST=1881, + XED_IFORMFL_TZCNT_FIRST=1882, + XED_IFORMFL_TZCNT_LAST=1883, + XED_IFORMFL_TZMSK_FIRST=1884, + XED_IFORMFL_TZMSK_LAST=1885, + XED_IFORMFL_UCOMISD_FIRST=1886, + XED_IFORMFL_UCOMISD_LAST=1887, + XED_IFORMFL_UCOMISS_FIRST=1888, + XED_IFORMFL_UCOMISS_LAST=1889, + XED_IFORMFL_UD2_FIRST=1890, + XED_IFORMFL_UD2_LAST=1890, + XED_IFORMFL_UNPCKHPD_FIRST=1891, + XED_IFORMFL_UNPCKHPD_LAST=1892, + XED_IFORMFL_UNPCKHPS_FIRST=1893, + XED_IFORMFL_UNPCKHPS_LAST=1894, + XED_IFORMFL_UNPCKLPD_FIRST=1895, + XED_IFORMFL_UNPCKLPD_LAST=1896, + XED_IFORMFL_UNPCKLPS_FIRST=1897, + XED_IFORMFL_UNPCKLPS_LAST=1898, + XED_IFORMFL_VADDPD_FIRST=1899, + XED_IFORMFL_VADDPD_LAST=1908, + XED_IFORMFL_VADDPS_FIRST=1909, + XED_IFORMFL_VADDPS_LAST=1918, + XED_IFORMFL_VADDSD_FIRST=1919, + XED_IFORMFL_VADDSD_LAST=1922, + XED_IFORMFL_VADDSS_FIRST=1923, + XED_IFORMFL_VADDSS_LAST=1926, + XED_IFORMFL_VADDSUBPD_FIRST=1927, + XED_IFORMFL_VADDSUBPD_LAST=1930, + XED_IFORMFL_VADDSUBPS_FIRST=1931, + XED_IFORMFL_VADDSUBPS_LAST=1934, + XED_IFORMFL_VAESDEC_FIRST=1935, + XED_IFORMFL_VAESDEC_LAST=1936, + XED_IFORMFL_VAESDECLAST_FIRST=1937, + XED_IFORMFL_VAESDECLAST_LAST=1938, + XED_IFORMFL_VAESENC_FIRST=1939, + XED_IFORMFL_VAESENC_LAST=1940, + XED_IFORMFL_VAESENCLAST_FIRST=1941, + XED_IFORMFL_VAESENCLAST_LAST=1942, + XED_IFORMFL_VAESIMC_FIRST=1943, + XED_IFORMFL_VAESIMC_LAST=1944, + XED_IFORMFL_VAESKEYGENASSIST_FIRST=1945, + XED_IFORMFL_VAESKEYGENASSIST_LAST=1946, + XED_IFORMFL_VALIGND_FIRST=1947, + XED_IFORMFL_VALIGND_LAST=1952, + XED_IFORMFL_VALIGNQ_FIRST=1953, + XED_IFORMFL_VALIGNQ_LAST=1958, + XED_IFORMFL_VANDNPD_FIRST=1959, + XED_IFORMFL_VANDNPD_LAST=1968, + XED_IFORMFL_VANDNPS_FIRST=1969, + XED_IFORMFL_VANDNPS_LAST=1978, + XED_IFORMFL_VANDPD_FIRST=1979, + XED_IFORMFL_VANDPD_LAST=1988, + XED_IFORMFL_VANDPS_FIRST=1989, + XED_IFORMFL_VANDPS_LAST=1998, + XED_IFORMFL_VBLENDMPD_FIRST=1999, + XED_IFORMFL_VBLENDMPD_LAST=2004, + XED_IFORMFL_VBLENDMPS_FIRST=2005, + XED_IFORMFL_VBLENDMPS_LAST=2010, + XED_IFORMFL_VBLENDPD_FIRST=2011, + XED_IFORMFL_VBLENDPD_LAST=2014, + XED_IFORMFL_VBLENDPS_FIRST=2015, + XED_IFORMFL_VBLENDPS_LAST=2018, + XED_IFORMFL_VBLENDVPD_FIRST=2019, + XED_IFORMFL_VBLENDVPD_LAST=2022, + XED_IFORMFL_VBLENDVPS_FIRST=2023, + XED_IFORMFL_VBLENDVPS_LAST=2026, + XED_IFORMFL_VBROADCASTF128_FIRST=2027, + XED_IFORMFL_VBROADCASTF128_LAST=2027, + XED_IFORMFL_VBROADCASTF32X2_FIRST=2028, + XED_IFORMFL_VBROADCASTF32X2_LAST=2031, + XED_IFORMFL_VBROADCASTF32X4_FIRST=2032, + XED_IFORMFL_VBROADCASTF32X4_LAST=2033, + XED_IFORMFL_VBROADCASTF32X8_FIRST=2034, + XED_IFORMFL_VBROADCASTF32X8_LAST=2034, + XED_IFORMFL_VBROADCASTF64X2_FIRST=2035, + XED_IFORMFL_VBROADCASTF64X2_LAST=2036, + XED_IFORMFL_VBROADCASTF64X4_FIRST=2037, + XED_IFORMFL_VBROADCASTF64X4_LAST=2037, + XED_IFORMFL_VBROADCASTI128_FIRST=2038, + XED_IFORMFL_VBROADCASTI128_LAST=2038, + XED_IFORMFL_VBROADCASTI32X2_FIRST=2039, + XED_IFORMFL_VBROADCASTI32X2_LAST=2044, + XED_IFORMFL_VBROADCASTI32X4_FIRST=2045, + XED_IFORMFL_VBROADCASTI32X4_LAST=2046, + XED_IFORMFL_VBROADCASTI32X8_FIRST=2047, + XED_IFORMFL_VBROADCASTI32X8_LAST=2047, + XED_IFORMFL_VBROADCASTI64X2_FIRST=2048, + XED_IFORMFL_VBROADCASTI64X2_LAST=2049, + XED_IFORMFL_VBROADCASTI64X4_FIRST=2050, + XED_IFORMFL_VBROADCASTI64X4_LAST=2050, + XED_IFORMFL_VBROADCASTSD_FIRST=2051, + XED_IFORMFL_VBROADCASTSD_LAST=2056, + XED_IFORMFL_VBROADCASTSS_FIRST=2057, + XED_IFORMFL_VBROADCASTSS_LAST=2066, + XED_IFORMFL_VCMPPD_FIRST=2067, + XED_IFORMFL_VCMPPD_LAST=2076, + XED_IFORMFL_VCMPPS_FIRST=2077, + XED_IFORMFL_VCMPPS_LAST=2086, + XED_IFORMFL_VCMPSD_FIRST=2087, + XED_IFORMFL_VCMPSD_LAST=2090, + XED_IFORMFL_VCMPSS_FIRST=2091, + XED_IFORMFL_VCMPSS_LAST=2094, + XED_IFORMFL_VCOMISD_FIRST=2095, + XED_IFORMFL_VCOMISD_LAST=2098, + XED_IFORMFL_VCOMISS_FIRST=2099, + XED_IFORMFL_VCOMISS_LAST=2102, + XED_IFORMFL_VCOMPRESSPD_FIRST=2103, + XED_IFORMFL_VCOMPRESSPD_LAST=2108, + XED_IFORMFL_VCOMPRESSPS_FIRST=2109, + XED_IFORMFL_VCOMPRESSPS_LAST=2114, + XED_IFORMFL_VCVTDQ2PD_FIRST=2115, + XED_IFORMFL_VCVTDQ2PD_LAST=2124, + XED_IFORMFL_VCVTDQ2PS_FIRST=2125, + XED_IFORMFL_VCVTDQ2PS_LAST=2134, + XED_IFORMFL_VCVTPD2DQ_FIRST=2135, + XED_IFORMFL_VCVTPD2DQ_LAST=2144, + XED_IFORMFL_VCVTPD2PS_FIRST=2145, + XED_IFORMFL_VCVTPD2PS_LAST=2154, + XED_IFORMFL_VCVTPD2QQ_FIRST=2155, + XED_IFORMFL_VCVTPD2QQ_LAST=2160, + XED_IFORMFL_VCVTPD2UDQ_FIRST=2161, + XED_IFORMFL_VCVTPD2UDQ_LAST=2166, + XED_IFORMFL_VCVTPD2UQQ_FIRST=2167, + XED_IFORMFL_VCVTPD2UQQ_LAST=2172, + XED_IFORMFL_VCVTPH2PS_FIRST=2173, + XED_IFORMFL_VCVTPH2PS_LAST=2182, + XED_IFORMFL_VCVTPS2DQ_FIRST=2183, + XED_IFORMFL_VCVTPS2DQ_LAST=2192, + XED_IFORMFL_VCVTPS2PD_FIRST=2193, + XED_IFORMFL_VCVTPS2PD_LAST=2202, + XED_IFORMFL_VCVTPS2PH_FIRST=2203, + XED_IFORMFL_VCVTPS2PH_LAST=2212, + XED_IFORMFL_VCVTPS2QQ_FIRST=2213, + XED_IFORMFL_VCVTPS2QQ_LAST=2218, + XED_IFORMFL_VCVTPS2UDQ_FIRST=2219, + XED_IFORMFL_VCVTPS2UDQ_LAST=2224, + XED_IFORMFL_VCVTPS2UQQ_FIRST=2225, + XED_IFORMFL_VCVTPS2UQQ_LAST=2230, + XED_IFORMFL_VCVTQQ2PD_FIRST=2231, + XED_IFORMFL_VCVTQQ2PD_LAST=2236, + XED_IFORMFL_VCVTQQ2PS_FIRST=2237, + XED_IFORMFL_VCVTQQ2PS_LAST=2242, + XED_IFORMFL_VCVTSD2SI_FIRST=2243, + XED_IFORMFL_VCVTSD2SI_LAST=2250, + XED_IFORMFL_VCVTSD2SS_FIRST=2251, + XED_IFORMFL_VCVTSD2SS_LAST=2254, + XED_IFORMFL_VCVTSD2USI_FIRST=2255, + XED_IFORMFL_VCVTSD2USI_LAST=2258, + XED_IFORMFL_VCVTSI2SD_FIRST=2259, + XED_IFORMFL_VCVTSI2SD_LAST=2266, + XED_IFORMFL_VCVTSI2SS_FIRST=2267, + XED_IFORMFL_VCVTSI2SS_LAST=2274, + XED_IFORMFL_VCVTSS2SD_FIRST=2275, + XED_IFORMFL_VCVTSS2SD_LAST=2278, + XED_IFORMFL_VCVTSS2SI_FIRST=2279, + XED_IFORMFL_VCVTSS2SI_LAST=2286, + XED_IFORMFL_VCVTSS2USI_FIRST=2287, + XED_IFORMFL_VCVTSS2USI_LAST=2290, + XED_IFORMFL_VCVTTPD2DQ_FIRST=2291, + XED_IFORMFL_VCVTTPD2DQ_LAST=2300, + XED_IFORMFL_VCVTTPD2QQ_FIRST=2301, + XED_IFORMFL_VCVTTPD2QQ_LAST=2306, + XED_IFORMFL_VCVTTPD2UDQ_FIRST=2307, + XED_IFORMFL_VCVTTPD2UDQ_LAST=2312, + XED_IFORMFL_VCVTTPD2UQQ_FIRST=2313, + XED_IFORMFL_VCVTTPD2UQQ_LAST=2318, + XED_IFORMFL_VCVTTPS2DQ_FIRST=2319, + XED_IFORMFL_VCVTTPS2DQ_LAST=2328, + XED_IFORMFL_VCVTTPS2QQ_FIRST=2329, + XED_IFORMFL_VCVTTPS2QQ_LAST=2334, + XED_IFORMFL_VCVTTPS2UDQ_FIRST=2335, + XED_IFORMFL_VCVTTPS2UDQ_LAST=2340, + XED_IFORMFL_VCVTTPS2UQQ_FIRST=2341, + XED_IFORMFL_VCVTTPS2UQQ_LAST=2346, + XED_IFORMFL_VCVTTSD2SI_FIRST=2347, + XED_IFORMFL_VCVTTSD2SI_LAST=2354, + XED_IFORMFL_VCVTTSD2USI_FIRST=2355, + XED_IFORMFL_VCVTTSD2USI_LAST=2358, + XED_IFORMFL_VCVTTSS2SI_FIRST=2359, + XED_IFORMFL_VCVTTSS2SI_LAST=2366, + XED_IFORMFL_VCVTTSS2USI_FIRST=2367, + XED_IFORMFL_VCVTTSS2USI_LAST=2370, + XED_IFORMFL_VCVTUDQ2PD_FIRST=2371, + XED_IFORMFL_VCVTUDQ2PD_LAST=2376, + XED_IFORMFL_VCVTUDQ2PS_FIRST=2377, + XED_IFORMFL_VCVTUDQ2PS_LAST=2382, + XED_IFORMFL_VCVTUQQ2PD_FIRST=2383, + XED_IFORMFL_VCVTUQQ2PD_LAST=2388, + XED_IFORMFL_VCVTUQQ2PS_FIRST=2389, + XED_IFORMFL_VCVTUQQ2PS_LAST=2394, + XED_IFORMFL_VCVTUSI2SD_FIRST=2395, + XED_IFORMFL_VCVTUSI2SD_LAST=2398, + XED_IFORMFL_VCVTUSI2SS_FIRST=2399, + XED_IFORMFL_VCVTUSI2SS_LAST=2402, + XED_IFORMFL_VDBPSADBW_FIRST=2403, + XED_IFORMFL_VDBPSADBW_LAST=2408, + XED_IFORMFL_VDIVPD_FIRST=2409, + XED_IFORMFL_VDIVPD_LAST=2418, + XED_IFORMFL_VDIVPS_FIRST=2419, + XED_IFORMFL_VDIVPS_LAST=2428, + XED_IFORMFL_VDIVSD_FIRST=2429, + XED_IFORMFL_VDIVSD_LAST=2432, + XED_IFORMFL_VDIVSS_FIRST=2433, + XED_IFORMFL_VDIVSS_LAST=2436, + XED_IFORMFL_VDPPD_FIRST=2437, + XED_IFORMFL_VDPPD_LAST=2438, + XED_IFORMFL_VDPPS_FIRST=2439, + XED_IFORMFL_VDPPS_LAST=2442, + XED_IFORMFL_VERR_FIRST=2443, + XED_IFORMFL_VERR_LAST=2444, + XED_IFORMFL_VERW_FIRST=2445, + XED_IFORMFL_VERW_LAST=2446, + XED_IFORMFL_VEXP2PD_FIRST=2447, + XED_IFORMFL_VEXP2PD_LAST=2448, + XED_IFORMFL_VEXP2PS_FIRST=2449, + XED_IFORMFL_VEXP2PS_LAST=2450, + XED_IFORMFL_VEXPANDPD_FIRST=2451, + XED_IFORMFL_VEXPANDPD_LAST=2456, + XED_IFORMFL_VEXPANDPS_FIRST=2457, + XED_IFORMFL_VEXPANDPS_LAST=2462, + XED_IFORMFL_VEXTRACTF128_FIRST=2463, + XED_IFORMFL_VEXTRACTF128_LAST=2464, + XED_IFORMFL_VEXTRACTF32X4_FIRST=2465, + XED_IFORMFL_VEXTRACTF32X4_LAST=2468, + XED_IFORMFL_VEXTRACTF32X8_FIRST=2469, + XED_IFORMFL_VEXTRACTF32X8_LAST=2470, + XED_IFORMFL_VEXTRACTF64X2_FIRST=2471, + XED_IFORMFL_VEXTRACTF64X2_LAST=2474, + XED_IFORMFL_VEXTRACTF64X4_FIRST=2475, + XED_IFORMFL_VEXTRACTF64X4_LAST=2476, + XED_IFORMFL_VEXTRACTI128_FIRST=2477, + XED_IFORMFL_VEXTRACTI128_LAST=2478, + XED_IFORMFL_VEXTRACTI32X4_FIRST=2479, + XED_IFORMFL_VEXTRACTI32X4_LAST=2482, + XED_IFORMFL_VEXTRACTI32X8_FIRST=2483, + XED_IFORMFL_VEXTRACTI32X8_LAST=2484, + XED_IFORMFL_VEXTRACTI64X2_FIRST=2485, + XED_IFORMFL_VEXTRACTI64X2_LAST=2488, + XED_IFORMFL_VEXTRACTI64X4_FIRST=2489, + XED_IFORMFL_VEXTRACTI64X4_LAST=2490, + XED_IFORMFL_VEXTRACTPS_FIRST=2491, + XED_IFORMFL_VEXTRACTPS_LAST=2494, + XED_IFORMFL_VFIXUPIMMPD_FIRST=2495, + XED_IFORMFL_VFIXUPIMMPD_LAST=2500, + XED_IFORMFL_VFIXUPIMMPS_FIRST=2501, + XED_IFORMFL_VFIXUPIMMPS_LAST=2506, + XED_IFORMFL_VFIXUPIMMSD_FIRST=2507, + XED_IFORMFL_VFIXUPIMMSD_LAST=2508, + XED_IFORMFL_VFIXUPIMMSS_FIRST=2509, + XED_IFORMFL_VFIXUPIMMSS_LAST=2510, + XED_IFORMFL_VFMADD132PD_FIRST=2511, + XED_IFORMFL_VFMADD132PD_LAST=2520, + XED_IFORMFL_VFMADD132PS_FIRST=2521, + XED_IFORMFL_VFMADD132PS_LAST=2530, + XED_IFORMFL_VFMADD132SD_FIRST=2531, + XED_IFORMFL_VFMADD132SD_LAST=2534, + XED_IFORMFL_VFMADD132SS_FIRST=2535, + XED_IFORMFL_VFMADD132SS_LAST=2538, + XED_IFORMFL_VFMADD213PD_FIRST=2539, + XED_IFORMFL_VFMADD213PD_LAST=2548, + XED_IFORMFL_VFMADD213PS_FIRST=2549, + XED_IFORMFL_VFMADD213PS_LAST=2558, + XED_IFORMFL_VFMADD213SD_FIRST=2559, + XED_IFORMFL_VFMADD213SD_LAST=2562, + XED_IFORMFL_VFMADD213SS_FIRST=2563, + XED_IFORMFL_VFMADD213SS_LAST=2566, + XED_IFORMFL_VFMADD231PD_FIRST=2567, + XED_IFORMFL_VFMADD231PD_LAST=2576, + XED_IFORMFL_VFMADD231PS_FIRST=2577, + XED_IFORMFL_VFMADD231PS_LAST=2586, + XED_IFORMFL_VFMADD231SD_FIRST=2587, + XED_IFORMFL_VFMADD231SD_LAST=2590, + XED_IFORMFL_VFMADD231SS_FIRST=2591, + XED_IFORMFL_VFMADD231SS_LAST=2594, + XED_IFORMFL_VFMADDPD_FIRST=2595, + XED_IFORMFL_VFMADDPD_LAST=2600, + XED_IFORMFL_VFMADDPS_FIRST=2601, + XED_IFORMFL_VFMADDPS_LAST=2606, + XED_IFORMFL_VFMADDSD_FIRST=2607, + XED_IFORMFL_VFMADDSD_LAST=2610, + XED_IFORMFL_VFMADDSS_FIRST=2611, + XED_IFORMFL_VFMADDSS_LAST=2614, + XED_IFORMFL_VFMADDSUB132PD_FIRST=2615, + XED_IFORMFL_VFMADDSUB132PD_LAST=2624, + XED_IFORMFL_VFMADDSUB132PS_FIRST=2625, + XED_IFORMFL_VFMADDSUB132PS_LAST=2634, + XED_IFORMFL_VFMADDSUB213PD_FIRST=2635, + XED_IFORMFL_VFMADDSUB213PD_LAST=2644, + XED_IFORMFL_VFMADDSUB213PS_FIRST=2645, + XED_IFORMFL_VFMADDSUB213PS_LAST=2654, + XED_IFORMFL_VFMADDSUB231PD_FIRST=2655, + XED_IFORMFL_VFMADDSUB231PD_LAST=2664, + XED_IFORMFL_VFMADDSUB231PS_FIRST=2665, + XED_IFORMFL_VFMADDSUB231PS_LAST=2674, + XED_IFORMFL_VFMADDSUBPD_FIRST=2675, + XED_IFORMFL_VFMADDSUBPD_LAST=2680, + XED_IFORMFL_VFMADDSUBPS_FIRST=2681, + XED_IFORMFL_VFMADDSUBPS_LAST=2686, + XED_IFORMFL_VFMSUB132PD_FIRST=2687, + XED_IFORMFL_VFMSUB132PD_LAST=2696, + XED_IFORMFL_VFMSUB132PS_FIRST=2697, + XED_IFORMFL_VFMSUB132PS_LAST=2706, + XED_IFORMFL_VFMSUB132SD_FIRST=2707, + XED_IFORMFL_VFMSUB132SD_LAST=2710, + XED_IFORMFL_VFMSUB132SS_FIRST=2711, + XED_IFORMFL_VFMSUB132SS_LAST=2714, + XED_IFORMFL_VFMSUB213PD_FIRST=2715, + XED_IFORMFL_VFMSUB213PD_LAST=2724, + XED_IFORMFL_VFMSUB213PS_FIRST=2725, + XED_IFORMFL_VFMSUB213PS_LAST=2734, + XED_IFORMFL_VFMSUB213SD_FIRST=2735, + XED_IFORMFL_VFMSUB213SD_LAST=2738, + XED_IFORMFL_VFMSUB213SS_FIRST=2739, + XED_IFORMFL_VFMSUB213SS_LAST=2742, + XED_IFORMFL_VFMSUB231PD_FIRST=2743, + XED_IFORMFL_VFMSUB231PD_LAST=2752, + XED_IFORMFL_VFMSUB231PS_FIRST=2753, + XED_IFORMFL_VFMSUB231PS_LAST=2762, + XED_IFORMFL_VFMSUB231SD_FIRST=2763, + XED_IFORMFL_VFMSUB231SD_LAST=2766, + XED_IFORMFL_VFMSUB231SS_FIRST=2767, + XED_IFORMFL_VFMSUB231SS_LAST=2770, + XED_IFORMFL_VFMSUBADD132PD_FIRST=2771, + XED_IFORMFL_VFMSUBADD132PD_LAST=2780, + XED_IFORMFL_VFMSUBADD132PS_FIRST=2781, + XED_IFORMFL_VFMSUBADD132PS_LAST=2790, + XED_IFORMFL_VFMSUBADD213PD_FIRST=2791, + XED_IFORMFL_VFMSUBADD213PD_LAST=2800, + XED_IFORMFL_VFMSUBADD213PS_FIRST=2801, + XED_IFORMFL_VFMSUBADD213PS_LAST=2810, + XED_IFORMFL_VFMSUBADD231PD_FIRST=2811, + XED_IFORMFL_VFMSUBADD231PD_LAST=2820, + XED_IFORMFL_VFMSUBADD231PS_FIRST=2821, + XED_IFORMFL_VFMSUBADD231PS_LAST=2830, + XED_IFORMFL_VFMSUBADDPD_FIRST=2831, + XED_IFORMFL_VFMSUBADDPD_LAST=2836, + XED_IFORMFL_VFMSUBADDPS_FIRST=2837, + XED_IFORMFL_VFMSUBADDPS_LAST=2842, + XED_IFORMFL_VFMSUBPD_FIRST=2843, + XED_IFORMFL_VFMSUBPD_LAST=2848, + XED_IFORMFL_VFMSUBPS_FIRST=2849, + XED_IFORMFL_VFMSUBPS_LAST=2854, + XED_IFORMFL_VFMSUBSD_FIRST=2855, + XED_IFORMFL_VFMSUBSD_LAST=2858, + XED_IFORMFL_VFMSUBSS_FIRST=2859, + XED_IFORMFL_VFMSUBSS_LAST=2862, + XED_IFORMFL_VFNMADD132PD_FIRST=2863, + XED_IFORMFL_VFNMADD132PD_LAST=2872, + XED_IFORMFL_VFNMADD132PS_FIRST=2873, + XED_IFORMFL_VFNMADD132PS_LAST=2882, + XED_IFORMFL_VFNMADD132SD_FIRST=2883, + XED_IFORMFL_VFNMADD132SD_LAST=2886, + XED_IFORMFL_VFNMADD132SS_FIRST=2887, + XED_IFORMFL_VFNMADD132SS_LAST=2890, + XED_IFORMFL_VFNMADD213PD_FIRST=2891, + XED_IFORMFL_VFNMADD213PD_LAST=2900, + XED_IFORMFL_VFNMADD213PS_FIRST=2901, + XED_IFORMFL_VFNMADD213PS_LAST=2910, + XED_IFORMFL_VFNMADD213SD_FIRST=2911, + XED_IFORMFL_VFNMADD213SD_LAST=2914, + XED_IFORMFL_VFNMADD213SS_FIRST=2915, + XED_IFORMFL_VFNMADD213SS_LAST=2918, + XED_IFORMFL_VFNMADD231PD_FIRST=2919, + XED_IFORMFL_VFNMADD231PD_LAST=2928, + XED_IFORMFL_VFNMADD231PS_FIRST=2929, + XED_IFORMFL_VFNMADD231PS_LAST=2938, + XED_IFORMFL_VFNMADD231SD_FIRST=2939, + XED_IFORMFL_VFNMADD231SD_LAST=2942, + XED_IFORMFL_VFNMADD231SS_FIRST=2943, + XED_IFORMFL_VFNMADD231SS_LAST=2946, + XED_IFORMFL_VFNMADDPD_FIRST=2947, + XED_IFORMFL_VFNMADDPD_LAST=2952, + XED_IFORMFL_VFNMADDPS_FIRST=2953, + XED_IFORMFL_VFNMADDPS_LAST=2958, + XED_IFORMFL_VFNMADDSD_FIRST=2959, + XED_IFORMFL_VFNMADDSD_LAST=2962, + XED_IFORMFL_VFNMADDSS_FIRST=2963, + XED_IFORMFL_VFNMADDSS_LAST=2966, + XED_IFORMFL_VFNMSUB132PD_FIRST=2967, + XED_IFORMFL_VFNMSUB132PD_LAST=2976, + XED_IFORMFL_VFNMSUB132PS_FIRST=2977, + XED_IFORMFL_VFNMSUB132PS_LAST=2986, + XED_IFORMFL_VFNMSUB132SD_FIRST=2987, + XED_IFORMFL_VFNMSUB132SD_LAST=2990, + XED_IFORMFL_VFNMSUB132SS_FIRST=2991, + XED_IFORMFL_VFNMSUB132SS_LAST=2994, + XED_IFORMFL_VFNMSUB213PD_FIRST=2995, + XED_IFORMFL_VFNMSUB213PD_LAST=3004, + XED_IFORMFL_VFNMSUB213PS_FIRST=3005, + XED_IFORMFL_VFNMSUB213PS_LAST=3014, + XED_IFORMFL_VFNMSUB213SD_FIRST=3015, + XED_IFORMFL_VFNMSUB213SD_LAST=3018, + XED_IFORMFL_VFNMSUB213SS_FIRST=3019, + XED_IFORMFL_VFNMSUB213SS_LAST=3022, + XED_IFORMFL_VFNMSUB231PD_FIRST=3023, + XED_IFORMFL_VFNMSUB231PD_LAST=3032, + XED_IFORMFL_VFNMSUB231PS_FIRST=3033, + XED_IFORMFL_VFNMSUB231PS_LAST=3042, + XED_IFORMFL_VFNMSUB231SD_FIRST=3043, + XED_IFORMFL_VFNMSUB231SD_LAST=3046, + XED_IFORMFL_VFNMSUB231SS_FIRST=3047, + XED_IFORMFL_VFNMSUB231SS_LAST=3050, + XED_IFORMFL_VFNMSUBPD_FIRST=3051, + XED_IFORMFL_VFNMSUBPD_LAST=3056, + XED_IFORMFL_VFNMSUBPS_FIRST=3057, + XED_IFORMFL_VFNMSUBPS_LAST=3062, + XED_IFORMFL_VFNMSUBSD_FIRST=3063, + XED_IFORMFL_VFNMSUBSD_LAST=3066, + XED_IFORMFL_VFNMSUBSS_FIRST=3067, + XED_IFORMFL_VFNMSUBSS_LAST=3070, + XED_IFORMFL_VFPCLASSPD_FIRST=3071, + XED_IFORMFL_VFPCLASSPD_LAST=3074, + XED_IFORMFL_VFPCLASSPS_FIRST=3075, + XED_IFORMFL_VFPCLASSPS_LAST=3078, + XED_IFORMFL_VFPCLASSSD_FIRST=3079, + XED_IFORMFL_VFPCLASSSD_LAST=3080, + XED_IFORMFL_VFPCLASSSS_FIRST=3081, + XED_IFORMFL_VFPCLASSSS_LAST=3082, + XED_IFORMFL_VFRCZPD_FIRST=3083, + XED_IFORMFL_VFRCZPD_LAST=3086, + XED_IFORMFL_VFRCZPS_FIRST=3087, + XED_IFORMFL_VFRCZPS_LAST=3090, + XED_IFORMFL_VFRCZSD_FIRST=3091, + XED_IFORMFL_VFRCZSD_LAST=3092, + XED_IFORMFL_VFRCZSS_FIRST=3093, + XED_IFORMFL_VFRCZSS_LAST=3094, + XED_IFORMFL_VGATHERDPD_FIRST=3095, + XED_IFORMFL_VGATHERDPD_LAST=3099, + XED_IFORMFL_VGATHERDPS_FIRST=3100, + XED_IFORMFL_VGATHERDPS_LAST=3104, + XED_IFORMFL_VGATHERPF0DPD_FIRST=3105, + XED_IFORMFL_VGATHERPF0DPD_LAST=3105, + XED_IFORMFL_VGATHERPF0DPS_FIRST=3106, + XED_IFORMFL_VGATHERPF0DPS_LAST=3106, + XED_IFORMFL_VGATHERPF0QPD_FIRST=3107, + XED_IFORMFL_VGATHERPF0QPD_LAST=3107, + XED_IFORMFL_VGATHERPF0QPS_FIRST=3108, + XED_IFORMFL_VGATHERPF0QPS_LAST=3108, + XED_IFORMFL_VGATHERPF1DPD_FIRST=3109, + XED_IFORMFL_VGATHERPF1DPD_LAST=3109, + XED_IFORMFL_VGATHERPF1DPS_FIRST=3110, + XED_IFORMFL_VGATHERPF1DPS_LAST=3110, + XED_IFORMFL_VGATHERPF1QPD_FIRST=3111, + XED_IFORMFL_VGATHERPF1QPD_LAST=3111, + XED_IFORMFL_VGATHERPF1QPS_FIRST=3112, + XED_IFORMFL_VGATHERPF1QPS_LAST=3112, + XED_IFORMFL_VGATHERQPD_FIRST=3113, + XED_IFORMFL_VGATHERQPD_LAST=3117, + XED_IFORMFL_VGATHERQPS_FIRST=3118, + XED_IFORMFL_VGATHERQPS_LAST=3122, + XED_IFORMFL_VGETEXPPD_FIRST=3123, + XED_IFORMFL_VGETEXPPD_LAST=3128, + XED_IFORMFL_VGETEXPPS_FIRST=3129, + XED_IFORMFL_VGETEXPPS_LAST=3134, + XED_IFORMFL_VGETEXPSD_FIRST=3135, + XED_IFORMFL_VGETEXPSD_LAST=3136, + XED_IFORMFL_VGETEXPSS_FIRST=3137, + XED_IFORMFL_VGETEXPSS_LAST=3138, + XED_IFORMFL_VGETMANTPD_FIRST=3139, + XED_IFORMFL_VGETMANTPD_LAST=3144, + XED_IFORMFL_VGETMANTPS_FIRST=3145, + XED_IFORMFL_VGETMANTPS_LAST=3150, + XED_IFORMFL_VGETMANTSD_FIRST=3151, + XED_IFORMFL_VGETMANTSD_LAST=3152, + XED_IFORMFL_VGETMANTSS_FIRST=3153, + XED_IFORMFL_VGETMANTSS_LAST=3154, + XED_IFORMFL_VHADDPD_FIRST=3155, + XED_IFORMFL_VHADDPD_LAST=3158, + XED_IFORMFL_VHADDPS_FIRST=3159, + XED_IFORMFL_VHADDPS_LAST=3162, + XED_IFORMFL_VHSUBPD_FIRST=3163, + XED_IFORMFL_VHSUBPD_LAST=3166, + XED_IFORMFL_VHSUBPS_FIRST=3167, + XED_IFORMFL_VHSUBPS_LAST=3170, + XED_IFORMFL_VINSERTF128_FIRST=3171, + XED_IFORMFL_VINSERTF128_LAST=3172, + XED_IFORMFL_VINSERTF32X4_FIRST=3173, + XED_IFORMFL_VINSERTF32X4_LAST=3176, + XED_IFORMFL_VINSERTF32X8_FIRST=3177, + XED_IFORMFL_VINSERTF32X8_LAST=3178, + XED_IFORMFL_VINSERTF64X2_FIRST=3179, + XED_IFORMFL_VINSERTF64X2_LAST=3182, + XED_IFORMFL_VINSERTF64X4_FIRST=3183, + XED_IFORMFL_VINSERTF64X4_LAST=3184, + XED_IFORMFL_VINSERTI128_FIRST=3185, + XED_IFORMFL_VINSERTI128_LAST=3186, + XED_IFORMFL_VINSERTI32X4_FIRST=3187, + XED_IFORMFL_VINSERTI32X4_LAST=3190, + XED_IFORMFL_VINSERTI32X8_FIRST=3191, + XED_IFORMFL_VINSERTI32X8_LAST=3192, + XED_IFORMFL_VINSERTI64X2_FIRST=3193, + XED_IFORMFL_VINSERTI64X2_LAST=3196, + XED_IFORMFL_VINSERTI64X4_FIRST=3197, + XED_IFORMFL_VINSERTI64X4_LAST=3198, + XED_IFORMFL_VINSERTPS_FIRST=3199, + XED_IFORMFL_VINSERTPS_LAST=3202, + XED_IFORMFL_VLDDQU_FIRST=3203, + XED_IFORMFL_VLDDQU_LAST=3204, + XED_IFORMFL_VLDMXCSR_FIRST=3205, + XED_IFORMFL_VLDMXCSR_LAST=3205, + XED_IFORMFL_VMASKMOVDQU_FIRST=3206, + XED_IFORMFL_VMASKMOVDQU_LAST=3206, + XED_IFORMFL_VMASKMOVPD_FIRST=3207, + XED_IFORMFL_VMASKMOVPD_LAST=3210, + XED_IFORMFL_VMASKMOVPS_FIRST=3211, + XED_IFORMFL_VMASKMOVPS_LAST=3214, + XED_IFORMFL_VMAXPD_FIRST=3215, + XED_IFORMFL_VMAXPD_LAST=3224, + XED_IFORMFL_VMAXPS_FIRST=3225, + XED_IFORMFL_VMAXPS_LAST=3234, + XED_IFORMFL_VMAXSD_FIRST=3235, + XED_IFORMFL_VMAXSD_LAST=3238, + XED_IFORMFL_VMAXSS_FIRST=3239, + XED_IFORMFL_VMAXSS_LAST=3242, + XED_IFORMFL_VMCALL_FIRST=3243, + XED_IFORMFL_VMCALL_LAST=3243, + XED_IFORMFL_VMCLEAR_FIRST=3244, + XED_IFORMFL_VMCLEAR_LAST=3244, + XED_IFORMFL_VMFUNC_FIRST=3245, + XED_IFORMFL_VMFUNC_LAST=3245, + XED_IFORMFL_VMINPD_FIRST=3246, + XED_IFORMFL_VMINPD_LAST=3255, + XED_IFORMFL_VMINPS_FIRST=3256, + XED_IFORMFL_VMINPS_LAST=3265, + XED_IFORMFL_VMINSD_FIRST=3266, + XED_IFORMFL_VMINSD_LAST=3269, + XED_IFORMFL_VMINSS_FIRST=3270, + XED_IFORMFL_VMINSS_LAST=3273, + XED_IFORMFL_VMLAUNCH_FIRST=3274, + XED_IFORMFL_VMLAUNCH_LAST=3274, + XED_IFORMFL_VMLOAD_FIRST=3275, + XED_IFORMFL_VMLOAD_LAST=3275, + XED_IFORMFL_VMMCALL_FIRST=3276, + XED_IFORMFL_VMMCALL_LAST=3276, + XED_IFORMFL_VMOVAPD_FIRST=3277, + XED_IFORMFL_VMOVAPD_LAST=3293, + XED_IFORMFL_VMOVAPS_FIRST=3294, + XED_IFORMFL_VMOVAPS_LAST=3310, + XED_IFORMFL_VMOVD_FIRST=3311, + XED_IFORMFL_VMOVD_LAST=3318, + XED_IFORMFL_VMOVDDUP_FIRST=3319, + XED_IFORMFL_VMOVDDUP_LAST=3328, + XED_IFORMFL_VMOVDQA_FIRST=3329, + XED_IFORMFL_VMOVDQA_LAST=3336, + XED_IFORMFL_VMOVDQA32_FIRST=3337, + XED_IFORMFL_VMOVDQA32_LAST=3345, + XED_IFORMFL_VMOVDQA64_FIRST=3346, + XED_IFORMFL_VMOVDQA64_LAST=3354, + XED_IFORMFL_VMOVDQU_FIRST=3355, + XED_IFORMFL_VMOVDQU_LAST=3362, + XED_IFORMFL_VMOVDQU16_FIRST=3363, + XED_IFORMFL_VMOVDQU16_LAST=3371, + XED_IFORMFL_VMOVDQU32_FIRST=3372, + XED_IFORMFL_VMOVDQU32_LAST=3380, + XED_IFORMFL_VMOVDQU64_FIRST=3381, + XED_IFORMFL_VMOVDQU64_LAST=3389, + XED_IFORMFL_VMOVDQU8_FIRST=3390, + XED_IFORMFL_VMOVDQU8_LAST=3398, + XED_IFORMFL_VMOVHLPS_FIRST=3399, + XED_IFORMFL_VMOVHLPS_LAST=3400, + XED_IFORMFL_VMOVHPD_FIRST=3401, + XED_IFORMFL_VMOVHPD_LAST=3404, + XED_IFORMFL_VMOVHPS_FIRST=3405, + XED_IFORMFL_VMOVHPS_LAST=3408, + XED_IFORMFL_VMOVLHPS_FIRST=3409, + XED_IFORMFL_VMOVLHPS_LAST=3410, + XED_IFORMFL_VMOVLPD_FIRST=3411, + XED_IFORMFL_VMOVLPD_LAST=3414, + XED_IFORMFL_VMOVLPS_FIRST=3415, + XED_IFORMFL_VMOVLPS_LAST=3418, + XED_IFORMFL_VMOVMSKPD_FIRST=3419, + XED_IFORMFL_VMOVMSKPD_LAST=3420, + XED_IFORMFL_VMOVMSKPS_FIRST=3421, + XED_IFORMFL_VMOVMSKPS_LAST=3422, + XED_IFORMFL_VMOVNTDQ_FIRST=3423, + XED_IFORMFL_VMOVNTDQ_LAST=3427, + XED_IFORMFL_VMOVNTDQA_FIRST=3428, + XED_IFORMFL_VMOVNTDQA_LAST=3432, + XED_IFORMFL_VMOVNTPD_FIRST=3433, + XED_IFORMFL_VMOVNTPD_LAST=3437, + XED_IFORMFL_VMOVNTPS_FIRST=3438, + XED_IFORMFL_VMOVNTPS_LAST=3442, + XED_IFORMFL_VMOVQ_FIRST=3443, + XED_IFORMFL_VMOVQ_LAST=3455, + XED_IFORMFL_VMOVSD_FIRST=3456, + XED_IFORMFL_VMOVSD_LAST=3462, + XED_IFORMFL_VMOVSHDUP_FIRST=3463, + XED_IFORMFL_VMOVSHDUP_LAST=3472, + XED_IFORMFL_VMOVSLDUP_FIRST=3473, + XED_IFORMFL_VMOVSLDUP_LAST=3482, + XED_IFORMFL_VMOVSS_FIRST=3483, + XED_IFORMFL_VMOVSS_LAST=3489, + XED_IFORMFL_VMOVUPD_FIRST=3490, + XED_IFORMFL_VMOVUPD_LAST=3506, + XED_IFORMFL_VMOVUPS_FIRST=3507, + XED_IFORMFL_VMOVUPS_LAST=3523, + XED_IFORMFL_VMPSADBW_FIRST=3524, + XED_IFORMFL_VMPSADBW_LAST=3527, + XED_IFORMFL_VMPTRLD_FIRST=3528, + XED_IFORMFL_VMPTRLD_LAST=3528, + XED_IFORMFL_VMPTRST_FIRST=3529, + XED_IFORMFL_VMPTRST_LAST=3529, + XED_IFORMFL_VMREAD_FIRST=3530, + XED_IFORMFL_VMREAD_LAST=3533, + XED_IFORMFL_VMRESUME_FIRST=3534, + XED_IFORMFL_VMRESUME_LAST=3534, + XED_IFORMFL_VMRUN_FIRST=3535, + XED_IFORMFL_VMRUN_LAST=3535, + XED_IFORMFL_VMSAVE_FIRST=3536, + XED_IFORMFL_VMSAVE_LAST=3536, + XED_IFORMFL_VMULPD_FIRST=3537, + XED_IFORMFL_VMULPD_LAST=3546, + XED_IFORMFL_VMULPS_FIRST=3547, + XED_IFORMFL_VMULPS_LAST=3556, + XED_IFORMFL_VMULSD_FIRST=3557, + XED_IFORMFL_VMULSD_LAST=3560, + XED_IFORMFL_VMULSS_FIRST=3561, + XED_IFORMFL_VMULSS_LAST=3564, + XED_IFORMFL_VMWRITE_FIRST=3565, + XED_IFORMFL_VMWRITE_LAST=3568, + XED_IFORMFL_VMXOFF_FIRST=3569, + XED_IFORMFL_VMXOFF_LAST=3569, + XED_IFORMFL_VMXON_FIRST=3570, + XED_IFORMFL_VMXON_LAST=3570, + XED_IFORMFL_VORPD_FIRST=3571, + XED_IFORMFL_VORPD_LAST=3580, + XED_IFORMFL_VORPS_FIRST=3581, + XED_IFORMFL_VORPS_LAST=3590, + XED_IFORMFL_VPABSB_FIRST=3591, + XED_IFORMFL_VPABSB_LAST=3600, + XED_IFORMFL_VPABSD_FIRST=3601, + XED_IFORMFL_VPABSD_LAST=3610, + XED_IFORMFL_VPABSQ_FIRST=3611, + XED_IFORMFL_VPABSQ_LAST=3616, + XED_IFORMFL_VPABSW_FIRST=3617, + XED_IFORMFL_VPABSW_LAST=3626, + XED_IFORMFL_VPACKSSDW_FIRST=3627, + XED_IFORMFL_VPACKSSDW_LAST=3636, + XED_IFORMFL_VPACKSSWB_FIRST=3637, + XED_IFORMFL_VPACKSSWB_LAST=3646, + XED_IFORMFL_VPACKUSDW_FIRST=3647, + XED_IFORMFL_VPACKUSDW_LAST=3656, + XED_IFORMFL_VPACKUSWB_FIRST=3657, + XED_IFORMFL_VPACKUSWB_LAST=3666, + XED_IFORMFL_VPADDB_FIRST=3667, + XED_IFORMFL_VPADDB_LAST=3676, + XED_IFORMFL_VPADDD_FIRST=3677, + XED_IFORMFL_VPADDD_LAST=3686, + XED_IFORMFL_VPADDQ_FIRST=3687, + XED_IFORMFL_VPADDQ_LAST=3696, + XED_IFORMFL_VPADDSB_FIRST=3697, + XED_IFORMFL_VPADDSB_LAST=3706, + XED_IFORMFL_VPADDSW_FIRST=3707, + XED_IFORMFL_VPADDSW_LAST=3716, + XED_IFORMFL_VPADDUSB_FIRST=3717, + XED_IFORMFL_VPADDUSB_LAST=3726, + XED_IFORMFL_VPADDUSW_FIRST=3727, + XED_IFORMFL_VPADDUSW_LAST=3736, + XED_IFORMFL_VPADDW_FIRST=3737, + XED_IFORMFL_VPADDW_LAST=3746, + XED_IFORMFL_VPALIGNR_FIRST=3747, + XED_IFORMFL_VPALIGNR_LAST=3756, + XED_IFORMFL_VPAND_FIRST=3757, + XED_IFORMFL_VPAND_LAST=3760, + XED_IFORMFL_VPANDD_FIRST=3761, + XED_IFORMFL_VPANDD_LAST=3766, + XED_IFORMFL_VPANDN_FIRST=3767, + XED_IFORMFL_VPANDN_LAST=3770, + XED_IFORMFL_VPANDND_FIRST=3771, + XED_IFORMFL_VPANDND_LAST=3776, + XED_IFORMFL_VPANDNQ_FIRST=3777, + XED_IFORMFL_VPANDNQ_LAST=3782, + XED_IFORMFL_VPANDQ_FIRST=3783, + XED_IFORMFL_VPANDQ_LAST=3788, + XED_IFORMFL_VPAVGB_FIRST=3789, + XED_IFORMFL_VPAVGB_LAST=3798, + XED_IFORMFL_VPAVGW_FIRST=3799, + XED_IFORMFL_VPAVGW_LAST=3808, + XED_IFORMFL_VPBLENDD_FIRST=3809, + XED_IFORMFL_VPBLENDD_LAST=3812, + XED_IFORMFL_VPBLENDMB_FIRST=3813, + XED_IFORMFL_VPBLENDMB_LAST=3818, + XED_IFORMFL_VPBLENDMD_FIRST=3819, + XED_IFORMFL_VPBLENDMD_LAST=3824, + XED_IFORMFL_VPBLENDMQ_FIRST=3825, + XED_IFORMFL_VPBLENDMQ_LAST=3830, + XED_IFORMFL_VPBLENDMW_FIRST=3831, + XED_IFORMFL_VPBLENDMW_LAST=3836, + XED_IFORMFL_VPBLENDVB_FIRST=3837, + XED_IFORMFL_VPBLENDVB_LAST=3840, + XED_IFORMFL_VPBLENDW_FIRST=3841, + XED_IFORMFL_VPBLENDW_LAST=3844, + XED_IFORMFL_VPBROADCASTB_FIRST=3845, + XED_IFORMFL_VPBROADCASTB_LAST=3857, + XED_IFORMFL_VPBROADCASTD_FIRST=3858, + XED_IFORMFL_VPBROADCASTD_LAST=3870, + XED_IFORMFL_VPBROADCASTMB2Q_FIRST=3871, + XED_IFORMFL_VPBROADCASTMB2Q_LAST=3873, + XED_IFORMFL_VPBROADCASTMW2D_FIRST=3874, + XED_IFORMFL_VPBROADCASTMW2D_LAST=3876, + XED_IFORMFL_VPBROADCASTQ_FIRST=3877, + XED_IFORMFL_VPBROADCASTQ_LAST=3889, + XED_IFORMFL_VPBROADCASTW_FIRST=3890, + XED_IFORMFL_VPBROADCASTW_LAST=3902, + XED_IFORMFL_VPCLMULQDQ_FIRST=3903, + XED_IFORMFL_VPCLMULQDQ_LAST=3904, + XED_IFORMFL_VPCMOV_FIRST=3905, + XED_IFORMFL_VPCMOV_LAST=3910, + XED_IFORMFL_VPCMPB_FIRST=3911, + XED_IFORMFL_VPCMPB_LAST=3916, + XED_IFORMFL_VPCMPD_FIRST=3917, + XED_IFORMFL_VPCMPD_LAST=3922, + XED_IFORMFL_VPCMPEQB_FIRST=3923, + XED_IFORMFL_VPCMPEQB_LAST=3932, + XED_IFORMFL_VPCMPEQD_FIRST=3933, + XED_IFORMFL_VPCMPEQD_LAST=3942, + XED_IFORMFL_VPCMPEQQ_FIRST=3943, + XED_IFORMFL_VPCMPEQQ_LAST=3952, + XED_IFORMFL_VPCMPEQW_FIRST=3953, + XED_IFORMFL_VPCMPEQW_LAST=3962, + XED_IFORMFL_VPCMPESTRI_FIRST=3963, + XED_IFORMFL_VPCMPESTRI_LAST=3964, + XED_IFORMFL_VPCMPESTRM_FIRST=3965, + XED_IFORMFL_VPCMPESTRM_LAST=3966, + XED_IFORMFL_VPCMPGTB_FIRST=3967, + XED_IFORMFL_VPCMPGTB_LAST=3976, + XED_IFORMFL_VPCMPGTD_FIRST=3977, + XED_IFORMFL_VPCMPGTD_LAST=3986, + XED_IFORMFL_VPCMPGTQ_FIRST=3987, + XED_IFORMFL_VPCMPGTQ_LAST=3996, + XED_IFORMFL_VPCMPGTW_FIRST=3997, + XED_IFORMFL_VPCMPGTW_LAST=4006, + XED_IFORMFL_VPCMPISTRI_FIRST=4007, + XED_IFORMFL_VPCMPISTRI_LAST=4008, + XED_IFORMFL_VPCMPISTRM_FIRST=4009, + XED_IFORMFL_VPCMPISTRM_LAST=4010, + XED_IFORMFL_VPCMPQ_FIRST=4011, + XED_IFORMFL_VPCMPQ_LAST=4016, + XED_IFORMFL_VPCMPUB_FIRST=4017, + XED_IFORMFL_VPCMPUB_LAST=4022, + XED_IFORMFL_VPCMPUD_FIRST=4023, + XED_IFORMFL_VPCMPUD_LAST=4028, + XED_IFORMFL_VPCMPUQ_FIRST=4029, + XED_IFORMFL_VPCMPUQ_LAST=4034, + XED_IFORMFL_VPCMPUW_FIRST=4035, + XED_IFORMFL_VPCMPUW_LAST=4040, + XED_IFORMFL_VPCMPW_FIRST=4041, + XED_IFORMFL_VPCMPW_LAST=4046, + XED_IFORMFL_VPCOMB_FIRST=4047, + XED_IFORMFL_VPCOMB_LAST=4048, + XED_IFORMFL_VPCOMD_FIRST=4049, + XED_IFORMFL_VPCOMD_LAST=4050, + XED_IFORMFL_VPCOMPRESSD_FIRST=4051, + XED_IFORMFL_VPCOMPRESSD_LAST=4056, + XED_IFORMFL_VPCOMPRESSQ_FIRST=4057, + XED_IFORMFL_VPCOMPRESSQ_LAST=4062, + XED_IFORMFL_VPCOMQ_FIRST=4063, + XED_IFORMFL_VPCOMQ_LAST=4064, + XED_IFORMFL_VPCOMUB_FIRST=4065, + XED_IFORMFL_VPCOMUB_LAST=4066, + XED_IFORMFL_VPCOMUD_FIRST=4067, + XED_IFORMFL_VPCOMUD_LAST=4068, + XED_IFORMFL_VPCOMUQ_FIRST=4069, + XED_IFORMFL_VPCOMUQ_LAST=4070, + XED_IFORMFL_VPCOMUW_FIRST=4071, + XED_IFORMFL_VPCOMUW_LAST=4072, + XED_IFORMFL_VPCOMW_FIRST=4073, + XED_IFORMFL_VPCOMW_LAST=4074, + XED_IFORMFL_VPCONFLICTD_FIRST=4075, + XED_IFORMFL_VPCONFLICTD_LAST=4080, + XED_IFORMFL_VPCONFLICTQ_FIRST=4081, + XED_IFORMFL_VPCONFLICTQ_LAST=4086, + XED_IFORMFL_VPERM2F128_FIRST=4087, + XED_IFORMFL_VPERM2F128_LAST=4088, + XED_IFORMFL_VPERM2I128_FIRST=4089, + XED_IFORMFL_VPERM2I128_LAST=4090, + XED_IFORMFL_VPERMB_FIRST=4091, + XED_IFORMFL_VPERMB_LAST=4096, + XED_IFORMFL_VPERMD_FIRST=4097, + XED_IFORMFL_VPERMD_LAST=4102, + XED_IFORMFL_VPERMI2B_FIRST=4103, + XED_IFORMFL_VPERMI2B_LAST=4108, + XED_IFORMFL_VPERMI2D_FIRST=4109, + XED_IFORMFL_VPERMI2D_LAST=4114, + XED_IFORMFL_VPERMI2PD_FIRST=4115, + XED_IFORMFL_VPERMI2PD_LAST=4120, + XED_IFORMFL_VPERMI2PS_FIRST=4121, + XED_IFORMFL_VPERMI2PS_LAST=4126, + XED_IFORMFL_VPERMI2Q_FIRST=4127, + XED_IFORMFL_VPERMI2Q_LAST=4132, + XED_IFORMFL_VPERMI2W_FIRST=4133, + XED_IFORMFL_VPERMI2W_LAST=4138, + XED_IFORMFL_VPERMIL2PD_FIRST=4139, + XED_IFORMFL_VPERMIL2PD_LAST=4144, + XED_IFORMFL_VPERMIL2PS_FIRST=4145, + XED_IFORMFL_VPERMIL2PS_LAST=4150, + XED_IFORMFL_VPERMILPD_FIRST=4151, + XED_IFORMFL_VPERMILPD_LAST=4170, + XED_IFORMFL_VPERMILPS_FIRST=4171, + XED_IFORMFL_VPERMILPS_LAST=4190, + XED_IFORMFL_VPERMPD_FIRST=4191, + XED_IFORMFL_VPERMPD_LAST=4200, + XED_IFORMFL_VPERMPS_FIRST=4201, + XED_IFORMFL_VPERMPS_LAST=4206, + XED_IFORMFL_VPERMQ_FIRST=4207, + XED_IFORMFL_VPERMQ_LAST=4216, + XED_IFORMFL_VPERMT2B_FIRST=4217, + XED_IFORMFL_VPERMT2B_LAST=4222, + XED_IFORMFL_VPERMT2D_FIRST=4223, + XED_IFORMFL_VPERMT2D_LAST=4228, + XED_IFORMFL_VPERMT2PD_FIRST=4229, + XED_IFORMFL_VPERMT2PD_LAST=4234, + XED_IFORMFL_VPERMT2PS_FIRST=4235, + XED_IFORMFL_VPERMT2PS_LAST=4240, + XED_IFORMFL_VPERMT2Q_FIRST=4241, + XED_IFORMFL_VPERMT2Q_LAST=4246, + XED_IFORMFL_VPERMT2W_FIRST=4247, + XED_IFORMFL_VPERMT2W_LAST=4252, + XED_IFORMFL_VPERMW_FIRST=4253, + XED_IFORMFL_VPERMW_LAST=4258, + XED_IFORMFL_VPEXPANDD_FIRST=4259, + XED_IFORMFL_VPEXPANDD_LAST=4264, + XED_IFORMFL_VPEXPANDQ_FIRST=4265, + XED_IFORMFL_VPEXPANDQ_LAST=4270, + XED_IFORMFL_VPEXTRB_FIRST=4271, + XED_IFORMFL_VPEXTRB_LAST=4274, + XED_IFORMFL_VPEXTRD_FIRST=4275, + XED_IFORMFL_VPEXTRD_LAST=4278, + XED_IFORMFL_VPEXTRQ_FIRST=4279, + XED_IFORMFL_VPEXTRQ_LAST=4282, + XED_IFORMFL_VPEXTRW_FIRST=4283, + XED_IFORMFL_VPEXTRW_LAST=4287, + XED_IFORMFL_VPGATHERDD_FIRST=4288, + XED_IFORMFL_VPGATHERDD_LAST=4292, + XED_IFORMFL_VPGATHERDQ_FIRST=4293, + XED_IFORMFL_VPGATHERDQ_LAST=4297, + XED_IFORMFL_VPGATHERQD_FIRST=4298, + XED_IFORMFL_VPGATHERQD_LAST=4302, + XED_IFORMFL_VPGATHERQQ_FIRST=4303, + XED_IFORMFL_VPGATHERQQ_LAST=4307, + XED_IFORMFL_VPHADDBD_FIRST=4308, + XED_IFORMFL_VPHADDBD_LAST=4309, + XED_IFORMFL_VPHADDBQ_FIRST=4310, + XED_IFORMFL_VPHADDBQ_LAST=4311, + XED_IFORMFL_VPHADDBW_FIRST=4312, + XED_IFORMFL_VPHADDBW_LAST=4313, + XED_IFORMFL_VPHADDD_FIRST=4314, + XED_IFORMFL_VPHADDD_LAST=4317, + XED_IFORMFL_VPHADDDQ_FIRST=4318, + XED_IFORMFL_VPHADDDQ_LAST=4319, + XED_IFORMFL_VPHADDSW_FIRST=4320, + XED_IFORMFL_VPHADDSW_LAST=4323, + XED_IFORMFL_VPHADDUBD_FIRST=4324, + XED_IFORMFL_VPHADDUBD_LAST=4325, + XED_IFORMFL_VPHADDUBQ_FIRST=4326, + XED_IFORMFL_VPHADDUBQ_LAST=4327, + XED_IFORMFL_VPHADDUBW_FIRST=4328, + XED_IFORMFL_VPHADDUBW_LAST=4329, + XED_IFORMFL_VPHADDUDQ_FIRST=4330, + XED_IFORMFL_VPHADDUDQ_LAST=4331, + XED_IFORMFL_VPHADDUWD_FIRST=4332, + XED_IFORMFL_VPHADDUWD_LAST=4333, + XED_IFORMFL_VPHADDUWQ_FIRST=4334, + XED_IFORMFL_VPHADDUWQ_LAST=4335, + XED_IFORMFL_VPHADDW_FIRST=4336, + XED_IFORMFL_VPHADDW_LAST=4339, + XED_IFORMFL_VPHADDWD_FIRST=4340, + XED_IFORMFL_VPHADDWD_LAST=4341, + XED_IFORMFL_VPHADDWQ_FIRST=4342, + XED_IFORMFL_VPHADDWQ_LAST=4343, + XED_IFORMFL_VPHMINPOSUW_FIRST=4344, + XED_IFORMFL_VPHMINPOSUW_LAST=4347, + XED_IFORMFL_VPHSUBBW_FIRST=4348, + XED_IFORMFL_VPHSUBBW_LAST=4349, + XED_IFORMFL_VPHSUBD_FIRST=4350, + XED_IFORMFL_VPHSUBD_LAST=4353, + XED_IFORMFL_VPHSUBDQ_FIRST=4354, + XED_IFORMFL_VPHSUBDQ_LAST=4355, + XED_IFORMFL_VPHSUBSW_FIRST=4356, + XED_IFORMFL_VPHSUBSW_LAST=4359, + XED_IFORMFL_VPHSUBW_FIRST=4360, + XED_IFORMFL_VPHSUBW_LAST=4363, + XED_IFORMFL_VPHSUBWD_FIRST=4364, + XED_IFORMFL_VPHSUBWD_LAST=4365, + XED_IFORMFL_VPINSRB_FIRST=4366, + XED_IFORMFL_VPINSRB_LAST=4369, + XED_IFORMFL_VPINSRD_FIRST=4370, + XED_IFORMFL_VPINSRD_LAST=4373, + XED_IFORMFL_VPINSRQ_FIRST=4374, + XED_IFORMFL_VPINSRQ_LAST=4377, + XED_IFORMFL_VPINSRW_FIRST=4378, + XED_IFORMFL_VPINSRW_LAST=4381, + XED_IFORMFL_VPLZCNTD_FIRST=4382, + XED_IFORMFL_VPLZCNTD_LAST=4387, + XED_IFORMFL_VPLZCNTQ_FIRST=4388, + XED_IFORMFL_VPLZCNTQ_LAST=4393, + XED_IFORMFL_VPMACSDD_FIRST=4394, + XED_IFORMFL_VPMACSDD_LAST=4395, + XED_IFORMFL_VPMACSDQH_FIRST=4396, + XED_IFORMFL_VPMACSDQH_LAST=4397, + XED_IFORMFL_VPMACSDQL_FIRST=4398, + XED_IFORMFL_VPMACSDQL_LAST=4399, + XED_IFORMFL_VPMACSSDD_FIRST=4400, + XED_IFORMFL_VPMACSSDD_LAST=4401, + XED_IFORMFL_VPMACSSDQH_FIRST=4402, + XED_IFORMFL_VPMACSSDQH_LAST=4403, + XED_IFORMFL_VPMACSSDQL_FIRST=4404, + XED_IFORMFL_VPMACSSDQL_LAST=4405, + XED_IFORMFL_VPMACSSWD_FIRST=4406, + XED_IFORMFL_VPMACSSWD_LAST=4407, + XED_IFORMFL_VPMACSSWW_FIRST=4408, + XED_IFORMFL_VPMACSSWW_LAST=4409, + XED_IFORMFL_VPMACSWD_FIRST=4410, + XED_IFORMFL_VPMACSWD_LAST=4411, + XED_IFORMFL_VPMACSWW_FIRST=4412, + XED_IFORMFL_VPMACSWW_LAST=4413, + XED_IFORMFL_VPMADCSSWD_FIRST=4414, + XED_IFORMFL_VPMADCSSWD_LAST=4415, + XED_IFORMFL_VPMADCSWD_FIRST=4416, + XED_IFORMFL_VPMADCSWD_LAST=4417, + XED_IFORMFL_VPMADD52HUQ_FIRST=4418, + XED_IFORMFL_VPMADD52HUQ_LAST=4423, + XED_IFORMFL_VPMADD52LUQ_FIRST=4424, + XED_IFORMFL_VPMADD52LUQ_LAST=4429, + XED_IFORMFL_VPMADDUBSW_FIRST=4430, + XED_IFORMFL_VPMADDUBSW_LAST=4439, + XED_IFORMFL_VPMADDWD_FIRST=4440, + XED_IFORMFL_VPMADDWD_LAST=4449, + XED_IFORMFL_VPMASKMOVD_FIRST=4450, + XED_IFORMFL_VPMASKMOVD_LAST=4453, + XED_IFORMFL_VPMASKMOVQ_FIRST=4454, + XED_IFORMFL_VPMASKMOVQ_LAST=4457, + XED_IFORMFL_VPMAXSB_FIRST=4458, + XED_IFORMFL_VPMAXSB_LAST=4467, + XED_IFORMFL_VPMAXSD_FIRST=4468, + XED_IFORMFL_VPMAXSD_LAST=4477, + XED_IFORMFL_VPMAXSQ_FIRST=4478, + XED_IFORMFL_VPMAXSQ_LAST=4483, + XED_IFORMFL_VPMAXSW_FIRST=4484, + XED_IFORMFL_VPMAXSW_LAST=4493, + XED_IFORMFL_VPMAXUB_FIRST=4494, + XED_IFORMFL_VPMAXUB_LAST=4503, + XED_IFORMFL_VPMAXUD_FIRST=4504, + XED_IFORMFL_VPMAXUD_LAST=4513, + XED_IFORMFL_VPMAXUQ_FIRST=4514, + XED_IFORMFL_VPMAXUQ_LAST=4519, + XED_IFORMFL_VPMAXUW_FIRST=4520, + XED_IFORMFL_VPMAXUW_LAST=4529, + XED_IFORMFL_VPMINSB_FIRST=4530, + XED_IFORMFL_VPMINSB_LAST=4539, + XED_IFORMFL_VPMINSD_FIRST=4540, + XED_IFORMFL_VPMINSD_LAST=4549, + XED_IFORMFL_VPMINSQ_FIRST=4550, + XED_IFORMFL_VPMINSQ_LAST=4555, + XED_IFORMFL_VPMINSW_FIRST=4556, + XED_IFORMFL_VPMINSW_LAST=4565, + XED_IFORMFL_VPMINUB_FIRST=4566, + XED_IFORMFL_VPMINUB_LAST=4575, + XED_IFORMFL_VPMINUD_FIRST=4576, + XED_IFORMFL_VPMINUD_LAST=4585, + XED_IFORMFL_VPMINUQ_FIRST=4586, + XED_IFORMFL_VPMINUQ_LAST=4591, + XED_IFORMFL_VPMINUW_FIRST=4592, + XED_IFORMFL_VPMINUW_LAST=4601, + XED_IFORMFL_VPMOVB2M_FIRST=4602, + XED_IFORMFL_VPMOVB2M_LAST=4604, + XED_IFORMFL_VPMOVD2M_FIRST=4605, + XED_IFORMFL_VPMOVD2M_LAST=4607, + XED_IFORMFL_VPMOVDB_FIRST=4608, + XED_IFORMFL_VPMOVDB_LAST=4613, + XED_IFORMFL_VPMOVDW_FIRST=4614, + XED_IFORMFL_VPMOVDW_LAST=4619, + XED_IFORMFL_VPMOVM2B_FIRST=4620, + XED_IFORMFL_VPMOVM2B_LAST=4622, + XED_IFORMFL_VPMOVM2D_FIRST=4623, + XED_IFORMFL_VPMOVM2D_LAST=4625, + XED_IFORMFL_VPMOVM2Q_FIRST=4626, + XED_IFORMFL_VPMOVM2Q_LAST=4628, + XED_IFORMFL_VPMOVM2W_FIRST=4629, + XED_IFORMFL_VPMOVM2W_LAST=4631, + XED_IFORMFL_VPMOVMSKB_FIRST=4632, + XED_IFORMFL_VPMOVMSKB_LAST=4633, + XED_IFORMFL_VPMOVQ2M_FIRST=4634, + XED_IFORMFL_VPMOVQ2M_LAST=4636, + XED_IFORMFL_VPMOVQB_FIRST=4637, + XED_IFORMFL_VPMOVQB_LAST=4642, + XED_IFORMFL_VPMOVQD_FIRST=4643, + XED_IFORMFL_VPMOVQD_LAST=4648, + XED_IFORMFL_VPMOVQW_FIRST=4649, + XED_IFORMFL_VPMOVQW_LAST=4654, + XED_IFORMFL_VPMOVSDB_FIRST=4655, + XED_IFORMFL_VPMOVSDB_LAST=4660, + XED_IFORMFL_VPMOVSDW_FIRST=4661, + XED_IFORMFL_VPMOVSDW_LAST=4666, + XED_IFORMFL_VPMOVSQB_FIRST=4667, + XED_IFORMFL_VPMOVSQB_LAST=4672, + XED_IFORMFL_VPMOVSQD_FIRST=4673, + XED_IFORMFL_VPMOVSQD_LAST=4678, + XED_IFORMFL_VPMOVSQW_FIRST=4679, + XED_IFORMFL_VPMOVSQW_LAST=4684, + XED_IFORMFL_VPMOVSWB_FIRST=4685, + XED_IFORMFL_VPMOVSWB_LAST=4690, + XED_IFORMFL_VPMOVSXBD_FIRST=4691, + XED_IFORMFL_VPMOVSXBD_LAST=4700, + XED_IFORMFL_VPMOVSXBQ_FIRST=4701, + XED_IFORMFL_VPMOVSXBQ_LAST=4710, + XED_IFORMFL_VPMOVSXBW_FIRST=4711, + XED_IFORMFL_VPMOVSXBW_LAST=4720, + XED_IFORMFL_VPMOVSXDQ_FIRST=4721, + XED_IFORMFL_VPMOVSXDQ_LAST=4730, + XED_IFORMFL_VPMOVSXWD_FIRST=4731, + XED_IFORMFL_VPMOVSXWD_LAST=4740, + XED_IFORMFL_VPMOVSXWQ_FIRST=4741, + XED_IFORMFL_VPMOVSXWQ_LAST=4750, + XED_IFORMFL_VPMOVUSDB_FIRST=4751, + XED_IFORMFL_VPMOVUSDB_LAST=4756, + XED_IFORMFL_VPMOVUSDW_FIRST=4757, + XED_IFORMFL_VPMOVUSDW_LAST=4762, + XED_IFORMFL_VPMOVUSQB_FIRST=4763, + XED_IFORMFL_VPMOVUSQB_LAST=4768, + XED_IFORMFL_VPMOVUSQD_FIRST=4769, + XED_IFORMFL_VPMOVUSQD_LAST=4774, + XED_IFORMFL_VPMOVUSQW_FIRST=4775, + XED_IFORMFL_VPMOVUSQW_LAST=4780, + XED_IFORMFL_VPMOVUSWB_FIRST=4781, + XED_IFORMFL_VPMOVUSWB_LAST=4786, + XED_IFORMFL_VPMOVW2M_FIRST=4787, + XED_IFORMFL_VPMOVW2M_LAST=4789, + XED_IFORMFL_VPMOVWB_FIRST=4790, + XED_IFORMFL_VPMOVWB_LAST=4795, + XED_IFORMFL_VPMOVZXBD_FIRST=4796, + XED_IFORMFL_VPMOVZXBD_LAST=4805, + XED_IFORMFL_VPMOVZXBQ_FIRST=4806, + XED_IFORMFL_VPMOVZXBQ_LAST=4815, + XED_IFORMFL_VPMOVZXBW_FIRST=4816, + XED_IFORMFL_VPMOVZXBW_LAST=4825, + XED_IFORMFL_VPMOVZXDQ_FIRST=4826, + XED_IFORMFL_VPMOVZXDQ_LAST=4835, + XED_IFORMFL_VPMOVZXWD_FIRST=4836, + XED_IFORMFL_VPMOVZXWD_LAST=4845, + XED_IFORMFL_VPMOVZXWQ_FIRST=4846, + XED_IFORMFL_VPMOVZXWQ_LAST=4855, + XED_IFORMFL_VPMULDQ_FIRST=4856, + XED_IFORMFL_VPMULDQ_LAST=4865, + XED_IFORMFL_VPMULHRSW_FIRST=4866, + XED_IFORMFL_VPMULHRSW_LAST=4875, + XED_IFORMFL_VPMULHUW_FIRST=4876, + XED_IFORMFL_VPMULHUW_LAST=4885, + XED_IFORMFL_VPMULHW_FIRST=4886, + XED_IFORMFL_VPMULHW_LAST=4895, + XED_IFORMFL_VPMULLD_FIRST=4896, + XED_IFORMFL_VPMULLD_LAST=4905, + XED_IFORMFL_VPMULLQ_FIRST=4906, + XED_IFORMFL_VPMULLQ_LAST=4911, + XED_IFORMFL_VPMULLW_FIRST=4912, + XED_IFORMFL_VPMULLW_LAST=4921, + XED_IFORMFL_VPMULTISHIFTQB_FIRST=4922, + XED_IFORMFL_VPMULTISHIFTQB_LAST=4927, + XED_IFORMFL_VPMULUDQ_FIRST=4928, + XED_IFORMFL_VPMULUDQ_LAST=4937, + XED_IFORMFL_VPOR_FIRST=4938, + XED_IFORMFL_VPOR_LAST=4941, + XED_IFORMFL_VPORD_FIRST=4942, + XED_IFORMFL_VPORD_LAST=4947, + XED_IFORMFL_VPORQ_FIRST=4948, + XED_IFORMFL_VPORQ_LAST=4953, + XED_IFORMFL_VPPERM_FIRST=4954, + XED_IFORMFL_VPPERM_LAST=4956, + XED_IFORMFL_VPROLD_FIRST=4957, + XED_IFORMFL_VPROLD_LAST=4962, + XED_IFORMFL_VPROLQ_FIRST=4963, + XED_IFORMFL_VPROLQ_LAST=4968, + XED_IFORMFL_VPROLVD_FIRST=4969, + XED_IFORMFL_VPROLVD_LAST=4974, + XED_IFORMFL_VPROLVQ_FIRST=4975, + XED_IFORMFL_VPROLVQ_LAST=4980, + XED_IFORMFL_VPRORD_FIRST=4981, + XED_IFORMFL_VPRORD_LAST=4986, + XED_IFORMFL_VPRORQ_FIRST=4987, + XED_IFORMFL_VPRORQ_LAST=4992, + XED_IFORMFL_VPRORVD_FIRST=4993, + XED_IFORMFL_VPRORVD_LAST=4998, + XED_IFORMFL_VPRORVQ_FIRST=4999, + XED_IFORMFL_VPRORVQ_LAST=5004, + XED_IFORMFL_VPROTB_FIRST=5005, + XED_IFORMFL_VPROTB_LAST=5009, + XED_IFORMFL_VPROTD_FIRST=5010, + XED_IFORMFL_VPROTD_LAST=5014, + XED_IFORMFL_VPROTQ_FIRST=5015, + XED_IFORMFL_VPROTQ_LAST=5019, + XED_IFORMFL_VPROTW_FIRST=5020, + XED_IFORMFL_VPROTW_LAST=5024, + XED_IFORMFL_VPSADBW_FIRST=5025, + XED_IFORMFL_VPSADBW_LAST=5034, + XED_IFORMFL_VPSCATTERDD_FIRST=5035, + XED_IFORMFL_VPSCATTERDD_LAST=5037, + XED_IFORMFL_VPSCATTERDQ_FIRST=5038, + XED_IFORMFL_VPSCATTERDQ_LAST=5040, + XED_IFORMFL_VPSCATTERQD_FIRST=5041, + XED_IFORMFL_VPSCATTERQD_LAST=5043, + XED_IFORMFL_VPSCATTERQQ_FIRST=5044, + XED_IFORMFL_VPSCATTERQQ_LAST=5046, + XED_IFORMFL_VPSHAB_FIRST=5047, + XED_IFORMFL_VPSHAB_LAST=5049, + XED_IFORMFL_VPSHAD_FIRST=5050, + XED_IFORMFL_VPSHAD_LAST=5052, + XED_IFORMFL_VPSHAQ_FIRST=5053, + XED_IFORMFL_VPSHAQ_LAST=5055, + XED_IFORMFL_VPSHAW_FIRST=5056, + XED_IFORMFL_VPSHAW_LAST=5058, + XED_IFORMFL_VPSHLB_FIRST=5059, + XED_IFORMFL_VPSHLB_LAST=5061, + XED_IFORMFL_VPSHLD_FIRST=5062, + XED_IFORMFL_VPSHLD_LAST=5064, + XED_IFORMFL_VPSHLQ_FIRST=5065, + XED_IFORMFL_VPSHLQ_LAST=5067, + XED_IFORMFL_VPSHLW_FIRST=5068, + XED_IFORMFL_VPSHLW_LAST=5070, + XED_IFORMFL_VPSHUFB_FIRST=5071, + XED_IFORMFL_VPSHUFB_LAST=5080, + XED_IFORMFL_VPSHUFD_FIRST=5081, + XED_IFORMFL_VPSHUFD_LAST=5090, + XED_IFORMFL_VPSHUFHW_FIRST=5091, + XED_IFORMFL_VPSHUFHW_LAST=5100, + XED_IFORMFL_VPSHUFLW_FIRST=5101, + XED_IFORMFL_VPSHUFLW_LAST=5110, + XED_IFORMFL_VPSIGNB_FIRST=5111, + XED_IFORMFL_VPSIGNB_LAST=5114, + XED_IFORMFL_VPSIGND_FIRST=5115, + XED_IFORMFL_VPSIGND_LAST=5118, + XED_IFORMFL_VPSIGNW_FIRST=5119, + XED_IFORMFL_VPSIGNW_LAST=5122, + XED_IFORMFL_VPSLLD_FIRST=5123, + XED_IFORMFL_VPSLLD_LAST=5140, + XED_IFORMFL_VPSLLDQ_FIRST=5141, + XED_IFORMFL_VPSLLDQ_LAST=5148, + XED_IFORMFL_VPSLLQ_FIRST=5149, + XED_IFORMFL_VPSLLQ_LAST=5166, + XED_IFORMFL_VPSLLVD_FIRST=5167, + XED_IFORMFL_VPSLLVD_LAST=5176, + XED_IFORMFL_VPSLLVQ_FIRST=5177, + XED_IFORMFL_VPSLLVQ_LAST=5186, + XED_IFORMFL_VPSLLVW_FIRST=5187, + XED_IFORMFL_VPSLLVW_LAST=5192, + XED_IFORMFL_VPSLLW_FIRST=5193, + XED_IFORMFL_VPSLLW_LAST=5210, + XED_IFORMFL_VPSRAD_FIRST=5211, + XED_IFORMFL_VPSRAD_LAST=5228, + XED_IFORMFL_VPSRAQ_FIRST=5229, + XED_IFORMFL_VPSRAQ_LAST=5240, + XED_IFORMFL_VPSRAVD_FIRST=5241, + XED_IFORMFL_VPSRAVD_LAST=5250, + XED_IFORMFL_VPSRAVQ_FIRST=5251, + XED_IFORMFL_VPSRAVQ_LAST=5256, + XED_IFORMFL_VPSRAVW_FIRST=5257, + XED_IFORMFL_VPSRAVW_LAST=5262, + XED_IFORMFL_VPSRAW_FIRST=5263, + XED_IFORMFL_VPSRAW_LAST=5280, + XED_IFORMFL_VPSRLD_FIRST=5281, + XED_IFORMFL_VPSRLD_LAST=5298, + XED_IFORMFL_VPSRLDQ_FIRST=5299, + XED_IFORMFL_VPSRLDQ_LAST=5306, + XED_IFORMFL_VPSRLQ_FIRST=5307, + XED_IFORMFL_VPSRLQ_LAST=5324, + XED_IFORMFL_VPSRLVD_FIRST=5325, + XED_IFORMFL_VPSRLVD_LAST=5334, + XED_IFORMFL_VPSRLVQ_FIRST=5335, + XED_IFORMFL_VPSRLVQ_LAST=5344, + XED_IFORMFL_VPSRLVW_FIRST=5345, + XED_IFORMFL_VPSRLVW_LAST=5350, + XED_IFORMFL_VPSRLW_FIRST=5351, + XED_IFORMFL_VPSRLW_LAST=5368, + XED_IFORMFL_VPSUBB_FIRST=5369, + XED_IFORMFL_VPSUBB_LAST=5378, + XED_IFORMFL_VPSUBD_FIRST=5379, + XED_IFORMFL_VPSUBD_LAST=5388, + XED_IFORMFL_VPSUBQ_FIRST=5389, + XED_IFORMFL_VPSUBQ_LAST=5398, + XED_IFORMFL_VPSUBSB_FIRST=5399, + XED_IFORMFL_VPSUBSB_LAST=5408, + XED_IFORMFL_VPSUBSW_FIRST=5409, + XED_IFORMFL_VPSUBSW_LAST=5418, + XED_IFORMFL_VPSUBUSB_FIRST=5419, + XED_IFORMFL_VPSUBUSB_LAST=5428, + XED_IFORMFL_VPSUBUSW_FIRST=5429, + XED_IFORMFL_VPSUBUSW_LAST=5438, + XED_IFORMFL_VPSUBW_FIRST=5439, + XED_IFORMFL_VPSUBW_LAST=5448, + XED_IFORMFL_VPTERNLOGD_FIRST=5449, + XED_IFORMFL_VPTERNLOGD_LAST=5454, + XED_IFORMFL_VPTERNLOGQ_FIRST=5455, + XED_IFORMFL_VPTERNLOGQ_LAST=5460, + XED_IFORMFL_VPTEST_FIRST=5461, + XED_IFORMFL_VPTEST_LAST=5464, + XED_IFORMFL_VPTESTMB_FIRST=5465, + XED_IFORMFL_VPTESTMB_LAST=5470, + XED_IFORMFL_VPTESTMD_FIRST=5471, + XED_IFORMFL_VPTESTMD_LAST=5476, + XED_IFORMFL_VPTESTMQ_FIRST=5477, + XED_IFORMFL_VPTESTMQ_LAST=5482, + XED_IFORMFL_VPTESTMW_FIRST=5483, + XED_IFORMFL_VPTESTMW_LAST=5488, + XED_IFORMFL_VPTESTNMB_FIRST=5489, + XED_IFORMFL_VPTESTNMB_LAST=5494, + XED_IFORMFL_VPTESTNMD_FIRST=5495, + XED_IFORMFL_VPTESTNMD_LAST=5500, + XED_IFORMFL_VPTESTNMQ_FIRST=5501, + XED_IFORMFL_VPTESTNMQ_LAST=5506, + XED_IFORMFL_VPTESTNMW_FIRST=5507, + XED_IFORMFL_VPTESTNMW_LAST=5512, + XED_IFORMFL_VPUNPCKHBW_FIRST=5513, + XED_IFORMFL_VPUNPCKHBW_LAST=5522, + XED_IFORMFL_VPUNPCKHDQ_FIRST=5523, + XED_IFORMFL_VPUNPCKHDQ_LAST=5532, + XED_IFORMFL_VPUNPCKHQDQ_FIRST=5533, + XED_IFORMFL_VPUNPCKHQDQ_LAST=5542, + XED_IFORMFL_VPUNPCKHWD_FIRST=5543, + XED_IFORMFL_VPUNPCKHWD_LAST=5552, + XED_IFORMFL_VPUNPCKLBW_FIRST=5553, + XED_IFORMFL_VPUNPCKLBW_LAST=5562, + XED_IFORMFL_VPUNPCKLDQ_FIRST=5563, + XED_IFORMFL_VPUNPCKLDQ_LAST=5572, + XED_IFORMFL_VPUNPCKLQDQ_FIRST=5573, + XED_IFORMFL_VPUNPCKLQDQ_LAST=5582, + XED_IFORMFL_VPUNPCKLWD_FIRST=5583, + XED_IFORMFL_VPUNPCKLWD_LAST=5592, + XED_IFORMFL_VPXOR_FIRST=5593, + XED_IFORMFL_VPXOR_LAST=5596, + XED_IFORMFL_VPXORD_FIRST=5597, + XED_IFORMFL_VPXORD_LAST=5602, + XED_IFORMFL_VPXORQ_FIRST=5603, + XED_IFORMFL_VPXORQ_LAST=5608, + XED_IFORMFL_VRANGEPD_FIRST=5609, + XED_IFORMFL_VRANGEPD_LAST=5614, + XED_IFORMFL_VRANGEPS_FIRST=5615, + XED_IFORMFL_VRANGEPS_LAST=5620, + XED_IFORMFL_VRANGESD_FIRST=5621, + XED_IFORMFL_VRANGESD_LAST=5622, + XED_IFORMFL_VRANGESS_FIRST=5623, + XED_IFORMFL_VRANGESS_LAST=5624, + XED_IFORMFL_VRCP14PD_FIRST=5625, + XED_IFORMFL_VRCP14PD_LAST=5630, + XED_IFORMFL_VRCP14PS_FIRST=5631, + XED_IFORMFL_VRCP14PS_LAST=5636, + XED_IFORMFL_VRCP14SD_FIRST=5637, + XED_IFORMFL_VRCP14SD_LAST=5638, + XED_IFORMFL_VRCP14SS_FIRST=5639, + XED_IFORMFL_VRCP14SS_LAST=5640, + XED_IFORMFL_VRCP28PD_FIRST=5641, + XED_IFORMFL_VRCP28PD_LAST=5642, + XED_IFORMFL_VRCP28PS_FIRST=5643, + XED_IFORMFL_VRCP28PS_LAST=5644, + XED_IFORMFL_VRCP28SD_FIRST=5645, + XED_IFORMFL_VRCP28SD_LAST=5646, + XED_IFORMFL_VRCP28SS_FIRST=5647, + XED_IFORMFL_VRCP28SS_LAST=5648, + XED_IFORMFL_VRCPPS_FIRST=5649, + XED_IFORMFL_VRCPPS_LAST=5652, + XED_IFORMFL_VRCPSS_FIRST=5653, + XED_IFORMFL_VRCPSS_LAST=5654, + XED_IFORMFL_VREDUCEPD_FIRST=5655, + XED_IFORMFL_VREDUCEPD_LAST=5660, + XED_IFORMFL_VREDUCEPS_FIRST=5661, + XED_IFORMFL_VREDUCEPS_LAST=5666, + XED_IFORMFL_VREDUCESD_FIRST=5667, + XED_IFORMFL_VREDUCESD_LAST=5668, + XED_IFORMFL_VREDUCESS_FIRST=5669, + XED_IFORMFL_VREDUCESS_LAST=5670, + XED_IFORMFL_VRNDSCALEPD_FIRST=5671, + XED_IFORMFL_VRNDSCALEPD_LAST=5676, + XED_IFORMFL_VRNDSCALEPS_FIRST=5677, + XED_IFORMFL_VRNDSCALEPS_LAST=5682, + XED_IFORMFL_VRNDSCALESD_FIRST=5683, + XED_IFORMFL_VRNDSCALESD_LAST=5684, + XED_IFORMFL_VRNDSCALESS_FIRST=5685, + XED_IFORMFL_VRNDSCALESS_LAST=5686, + XED_IFORMFL_VROUNDPD_FIRST=5687, + XED_IFORMFL_VROUNDPD_LAST=5690, + XED_IFORMFL_VROUNDPS_FIRST=5691, + XED_IFORMFL_VROUNDPS_LAST=5694, + XED_IFORMFL_VROUNDSD_FIRST=5695, + XED_IFORMFL_VROUNDSD_LAST=5696, + XED_IFORMFL_VROUNDSS_FIRST=5697, + XED_IFORMFL_VROUNDSS_LAST=5698, + XED_IFORMFL_VRSQRT14PD_FIRST=5699, + XED_IFORMFL_VRSQRT14PD_LAST=5704, + XED_IFORMFL_VRSQRT14PS_FIRST=5705, + XED_IFORMFL_VRSQRT14PS_LAST=5710, + XED_IFORMFL_VRSQRT14SD_FIRST=5711, + XED_IFORMFL_VRSQRT14SD_LAST=5712, + XED_IFORMFL_VRSQRT14SS_FIRST=5713, + XED_IFORMFL_VRSQRT14SS_LAST=5714, + XED_IFORMFL_VRSQRT28PD_FIRST=5715, + XED_IFORMFL_VRSQRT28PD_LAST=5716, + XED_IFORMFL_VRSQRT28PS_FIRST=5717, + XED_IFORMFL_VRSQRT28PS_LAST=5718, + XED_IFORMFL_VRSQRT28SD_FIRST=5719, + XED_IFORMFL_VRSQRT28SD_LAST=5720, + XED_IFORMFL_VRSQRT28SS_FIRST=5721, + XED_IFORMFL_VRSQRT28SS_LAST=5722, + XED_IFORMFL_VRSQRTPS_FIRST=5723, + XED_IFORMFL_VRSQRTPS_LAST=5726, + XED_IFORMFL_VRSQRTSS_FIRST=5727, + XED_IFORMFL_VRSQRTSS_LAST=5728, + XED_IFORMFL_VSCALEFPD_FIRST=5729, + XED_IFORMFL_VSCALEFPD_LAST=5734, + XED_IFORMFL_VSCALEFPS_FIRST=5735, + XED_IFORMFL_VSCALEFPS_LAST=5740, + XED_IFORMFL_VSCALEFSD_FIRST=5741, + XED_IFORMFL_VSCALEFSD_LAST=5742, + XED_IFORMFL_VSCALEFSS_FIRST=5743, + XED_IFORMFL_VSCALEFSS_LAST=5744, + XED_IFORMFL_VSCATTERDPD_FIRST=5745, + XED_IFORMFL_VSCATTERDPD_LAST=5747, + XED_IFORMFL_VSCATTERDPS_FIRST=5748, + XED_IFORMFL_VSCATTERDPS_LAST=5750, + XED_IFORMFL_VSCATTERPF0DPD_FIRST=5751, + XED_IFORMFL_VSCATTERPF0DPD_LAST=5751, + XED_IFORMFL_VSCATTERPF0DPS_FIRST=5752, + XED_IFORMFL_VSCATTERPF0DPS_LAST=5752, + XED_IFORMFL_VSCATTERPF0QPD_FIRST=5753, + XED_IFORMFL_VSCATTERPF0QPD_LAST=5753, + XED_IFORMFL_VSCATTERPF0QPS_FIRST=5754, + XED_IFORMFL_VSCATTERPF0QPS_LAST=5754, + XED_IFORMFL_VSCATTERPF1DPD_FIRST=5755, + XED_IFORMFL_VSCATTERPF1DPD_LAST=5755, + XED_IFORMFL_VSCATTERPF1DPS_FIRST=5756, + XED_IFORMFL_VSCATTERPF1DPS_LAST=5756, + XED_IFORMFL_VSCATTERPF1QPD_FIRST=5757, + XED_IFORMFL_VSCATTERPF1QPD_LAST=5757, + XED_IFORMFL_VSCATTERPF1QPS_FIRST=5758, + XED_IFORMFL_VSCATTERPF1QPS_LAST=5758, + XED_IFORMFL_VSCATTERQPD_FIRST=5759, + XED_IFORMFL_VSCATTERQPD_LAST=5761, + XED_IFORMFL_VSCATTERQPS_FIRST=5762, + XED_IFORMFL_VSCATTERQPS_LAST=5764, + XED_IFORMFL_VSHUFF32X4_FIRST=5765, + XED_IFORMFL_VSHUFF32X4_LAST=5768, + XED_IFORMFL_VSHUFF64X2_FIRST=5769, + XED_IFORMFL_VSHUFF64X2_LAST=5772, + XED_IFORMFL_VSHUFI32X4_FIRST=5773, + XED_IFORMFL_VSHUFI32X4_LAST=5776, + XED_IFORMFL_VSHUFI64X2_FIRST=5777, + XED_IFORMFL_VSHUFI64X2_LAST=5780, + XED_IFORMFL_VSHUFPD_FIRST=5781, + XED_IFORMFL_VSHUFPD_LAST=5790, + XED_IFORMFL_VSHUFPS_FIRST=5791, + XED_IFORMFL_VSHUFPS_LAST=5800, + XED_IFORMFL_VSQRTPD_FIRST=5801, + XED_IFORMFL_VSQRTPD_LAST=5810, + XED_IFORMFL_VSQRTPS_FIRST=5811, + XED_IFORMFL_VSQRTPS_LAST=5820, + XED_IFORMFL_VSQRTSD_FIRST=5821, + XED_IFORMFL_VSQRTSD_LAST=5824, + XED_IFORMFL_VSQRTSS_FIRST=5825, + XED_IFORMFL_VSQRTSS_LAST=5828, + XED_IFORMFL_VSTMXCSR_FIRST=5829, + XED_IFORMFL_VSTMXCSR_LAST=5829, + XED_IFORMFL_VSUBPD_FIRST=5830, + XED_IFORMFL_VSUBPD_LAST=5839, + XED_IFORMFL_VSUBPS_FIRST=5840, + XED_IFORMFL_VSUBPS_LAST=5849, + XED_IFORMFL_VSUBSD_FIRST=5850, + XED_IFORMFL_VSUBSD_LAST=5853, + XED_IFORMFL_VSUBSS_FIRST=5854, + XED_IFORMFL_VSUBSS_LAST=5857, + XED_IFORMFL_VTESTPD_FIRST=5858, + XED_IFORMFL_VTESTPD_LAST=5861, + XED_IFORMFL_VTESTPS_FIRST=5862, + XED_IFORMFL_VTESTPS_LAST=5865, + XED_IFORMFL_VUCOMISD_FIRST=5866, + XED_IFORMFL_VUCOMISD_LAST=5869, + XED_IFORMFL_VUCOMISS_FIRST=5870, + XED_IFORMFL_VUCOMISS_LAST=5873, + XED_IFORMFL_VUNPCKHPD_FIRST=5874, + XED_IFORMFL_VUNPCKHPD_LAST=5883, + XED_IFORMFL_VUNPCKHPS_FIRST=5884, + XED_IFORMFL_VUNPCKHPS_LAST=5893, + XED_IFORMFL_VUNPCKLPD_FIRST=5894, + XED_IFORMFL_VUNPCKLPD_LAST=5903, + XED_IFORMFL_VUNPCKLPS_FIRST=5904, + XED_IFORMFL_VUNPCKLPS_LAST=5913, + XED_IFORMFL_VXORPD_FIRST=5914, + XED_IFORMFL_VXORPD_LAST=5923, + XED_IFORMFL_VXORPS_FIRST=5924, + XED_IFORMFL_VXORPS_LAST=5933, + XED_IFORMFL_VZEROALL_FIRST=5934, + XED_IFORMFL_VZEROALL_LAST=5934, + XED_IFORMFL_VZEROUPPER_FIRST=5935, + XED_IFORMFL_VZEROUPPER_LAST=5935, + XED_IFORMFL_WBINVD_FIRST=5936, + XED_IFORMFL_WBINVD_LAST=5936, + XED_IFORMFL_WRFSBASE_FIRST=5937, + XED_IFORMFL_WRFSBASE_LAST=5937, + XED_IFORMFL_WRGSBASE_FIRST=5938, + XED_IFORMFL_WRGSBASE_LAST=5938, + XED_IFORMFL_WRMSR_FIRST=5939, + XED_IFORMFL_WRMSR_LAST=5939, + XED_IFORMFL_XABORT_FIRST=5940, + XED_IFORMFL_XABORT_LAST=5940, + XED_IFORMFL_XADD_FIRST=5941, + XED_IFORMFL_XADD_LAST=5944, + XED_IFORMFL_XADD_LOCK_FIRST=5945, + XED_IFORMFL_XADD_LOCK_LAST=5946, + XED_IFORMFL_XBEGIN_FIRST=5947, + XED_IFORMFL_XBEGIN_LAST=5947, + XED_IFORMFL_XCHG_FIRST=5948, + XED_IFORMFL_XCHG_LAST=5952, + XED_IFORMFL_XEND_FIRST=5953, + XED_IFORMFL_XEND_LAST=5953, + XED_IFORMFL_XGETBV_FIRST=5954, + XED_IFORMFL_XGETBV_LAST=5954, + XED_IFORMFL_XLAT_FIRST=5955, + XED_IFORMFL_XLAT_LAST=5955, + XED_IFORMFL_XOR_FIRST=5956, + XED_IFORMFL_XOR_LAST=5973, + XED_IFORMFL_XORPD_FIRST=5974, + XED_IFORMFL_XORPD_LAST=5975, + XED_IFORMFL_XORPS_FIRST=5976, + XED_IFORMFL_XORPS_LAST=5977, + XED_IFORMFL_XOR_LOCK_FIRST=5978, + XED_IFORMFL_XOR_LOCK_LAST=5983, + XED_IFORMFL_XRSTOR_FIRST=5984, + XED_IFORMFL_XRSTOR_LAST=5984, + XED_IFORMFL_XRSTOR64_FIRST=5985, + XED_IFORMFL_XRSTOR64_LAST=5985, + XED_IFORMFL_XRSTORS_FIRST=5986, + XED_IFORMFL_XRSTORS_LAST=5986, + XED_IFORMFL_XRSTORS64_FIRST=5987, + XED_IFORMFL_XRSTORS64_LAST=5987, + XED_IFORMFL_XSAVE_FIRST=5988, + XED_IFORMFL_XSAVE_LAST=5988, + XED_IFORMFL_XSAVE64_FIRST=5989, + XED_IFORMFL_XSAVE64_LAST=5989, + XED_IFORMFL_XSAVEC_FIRST=5990, + XED_IFORMFL_XSAVEC_LAST=5990, + XED_IFORMFL_XSAVEC64_FIRST=5991, + XED_IFORMFL_XSAVEC64_LAST=5991, + XED_IFORMFL_XSAVEOPT_FIRST=5992, + XED_IFORMFL_XSAVEOPT_LAST=5992, + XED_IFORMFL_XSAVEOPT64_FIRST=5993, + XED_IFORMFL_XSAVEOPT64_LAST=5993, + XED_IFORMFL_XSAVES_FIRST=5994, + XED_IFORMFL_XSAVES_LAST=5994, + XED_IFORMFL_XSAVES64_FIRST=5995, + XED_IFORMFL_XSAVES64_LAST=5995, + XED_IFORMFL_XSETBV_FIRST=5996, + XED_IFORMFL_XSETBV_LAST=5996, + XED_IFORMFL_XTEST_FIRST=5997, + XED_IFORMFL_XTEST_LAST=5997, + XED_IFORMFL_LAST +} xed_iformfl_enum_t; + +/// Returns the last element of the enumeration +/// @return xed_iformfl_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_iformfl_enum_t xed_iformfl_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-ild.h b/third_party/xed-intel64/include/xed-ild.h new file mode 100644 index 0000000..1ac2ae5 --- /dev/null +++ b/third_party/xed-intel64/include/xed-ild.h @@ -0,0 +1,75 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +/// @file xed-ild.h +/// instruction length decoder + +#if !defined(_XED_ILD_H_) +# define _XED_ILD_H_ +#include "xed-operand-accessors.h" +#include "../../../third_party/xed-intel64/include/xed-common-defs.h" +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-operand-accessors.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +/// This function just does instruction length decoding. +/// It does not return a fully decoded instruction. +/// @param xedd the decoded instruction of type #xed_decoded_inst_t . +/// Mode/state sent in via xedd; See the #xed_state_t . +/// @param itext the pointer to the array of instruction text bytes +/// @param bytes the length of the itext input array. +/// 1 to 15 bytes, anything more is ignored. +/// @return #xed_error_enum_t indiciating success (#XED_ERROR_NONE) or +/// failure. +/// Only two failure codes are valid for this function: +/// #XED_ERROR_BUFFER_TOO_SHORT and #XED_ERROR_GENERAL_ERROR. +/// In general this function cannot tell if the instruction is valid or +/// not. For valid instructions, XED can figure out if enough bytes were +/// provided to decode the instruction. If not enough were provided, +/// XED returns #XED_ERROR_BUFFER_TOO_SHORT. +/// From this function, the #XED_ERROR_GENERAL_ERROR is an indication +/// that XED could not decode the instruction's length because the +/// instruction was so invalid that even its length +/// may across implmentations. +/// +/// @ingroup DEC +XED_DLL_EXPORT xed_error_enum_t +xed_ild_decode(xed_decoded_inst_t* xedd, + const xed_uint8_t* itext, + const unsigned int bytes); + + +#endif + diff --git a/third_party/xed-intel64/include/xed-immdis.h b/third_party/xed-intel64/include/xed-immdis.h new file mode 100644 index 0000000..a789fc3 --- /dev/null +++ b/third_party/xed-intel64/include/xed-immdis.h @@ -0,0 +1,214 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-immdis.h +/// + + + +#ifndef _XED_IMMDIS_H_ +# define _XED_IMMDIS_H_ + +#include "../../../third_party/xed-intel64/include/xed-common-defs.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" +#include "../../../third_party/xed-intel64/include/xed-util.h" + + +//////////////////////////////////////////////////////////////////////////// +// DEFINES +//////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////// +// TYPES +//////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////// +// PROTOTYPES +//////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////// +// GLOBALS +//////////////////////////////////////////////////////////////////////////// + +#define XED_MAX_IMMDIS_BYTES 8 + +// A union for speed of zeroing +union xed_immdis_values_t +{ + xed_uint8_t x[XED_MAX_IMMDIS_BYTES];// STORED LITTLE ENDIAN. BYTE 0 is LSB + xed_uint64_t q; +}; + +/// Stores immediates and displacements for the encoder & decoder. +typedef struct xed_immdis_s { + union xed_immdis_values_t value; + unsigned int currently_used_space :4; // current number of assigned bytes + unsigned int max_allocated_space :4; // max allocation, 4 or 8 + xed_bool_t present : 1; + xed_bool_t immediate_is_unsigned : 1; +} xed_immdis_t; + +XED_DLL_EXPORT void xed_immdis__check(xed_immdis_t* q, int p) ; + + +XED_DLL_EXPORT void xed_immdis_init(xed_immdis_t* p, int max_bytes); + +/// @name Sizes and lengths +//@{ +/// return the number of bytes added +XED_DLL_EXPORT unsigned int xed_immdis_get_bytes(const xed_immdis_t* p) ; + +//@} + +/// @name Accessors for the value of the immediate or displacement +//@{ +XED_DLL_EXPORT xed_int64_t +xed_immdis_get_signed64(const xed_immdis_t* p); + +XED_DLL_EXPORT xed_uint64_t +xed_immdis_get_unsigned64(const xed_immdis_t* p); + +XED_DLL_EXPORT xed_bool_t +xed_immdis_is_zero(const xed_immdis_t* p) ; + +XED_DLL_EXPORT xed_bool_t +xed_immdis_is_one(const xed_immdis_t* p) ; + +/// Access the i'th byte of the immediate +XED_DLL_EXPORT xed_uint8_t xed_immdis_get_byte(const xed_immdis_t* p, unsigned int i) ; +//@} + +/// @name Presence / absence of an immediate or displacement +//@{ +XED_DLL_EXPORT void xed_immdis_set_present(xed_immdis_t* p) ; + +/// True if the object has had a value or individual bytes added to it. +XED_DLL_EXPORT xed_bool_t xed_immdis_is_present(const xed_immdis_t* p) ; +//@} + + +/// @name Initialization and setup +//@{ +XED_DLL_EXPORT void xed_immdis_set_max_len(xed_immdis_t* p, unsigned int mx) ; +XED_DLL_EXPORT void +xed_immdis_zero(xed_immdis_t* p); + +XED_DLL_EXPORT unsigned int xed_immdis_get_max_length(const xed_immdis_t* p) ; + +//@} + +/// @name Signed vs Unsigned +//@{ +/// Return true if signed. +XED_DLL_EXPORT xed_bool_t +xed_immdis_is_unsigned(const xed_immdis_t* p) ; +/// Return true if signed. +XED_DLL_EXPORT xed_bool_t +xed_immdis_is_signed(const xed_immdis_t* p) ; + +/// Set the immediate to be signed; For decoder use only. +XED_DLL_EXPORT void +xed_immdis_set_signed(xed_immdis_t* p) ; +/// Set the immediate to be unsigned; For decoder use only. +XED_DLL_EXPORT void +xed_immdis_set_unsigned( xed_immdis_t* p) ; +//@} + + +/// @name Adding / setting values +//@{ +XED_DLL_EXPORT void +xed_immdis_add_byte(xed_immdis_t* p, xed_uint8_t b); + + +XED_DLL_EXPORT void +xed_immdis_add_byte_array(xed_immdis_t* p, int nb, xed_uint8_t* ba); + +/// Add 1, 2, 4 or 8 bytes depending on the value x and the mask of +/// legal_widths. The default value of legal_widths = 0x5 only stops +/// adding bytes only on 1 or 4 byte quantities - depending on which +/// bytes of x are zero -- as is used for most memory addressing. You +/// can set legal_widths to 0x7 for branches (1, 2 or 4 byte branch +/// displacements). Or if you have an 8B displacement, you can set +/// legal_widths to 0x8. NOTE: add_shortest_width will add up to +/// XED_MAX_IMMDIS_BYTES if the x value requires it. NOTE: 16b memory +/// addressing can have 16b immediates. +XED_DLL_EXPORT void +xed_immdis_add_shortest_width_signed(xed_immdis_t* p, xed_int64_t x, xed_uint8_t legal_widths); + +/// See add_shortest_width_signed() +XED_DLL_EXPORT void +xed_immdis_add_shortest_width_unsigned(xed_immdis_t* p, xed_uint64_t x, xed_uint8_t legal_widths ); + + +/// add an 8 bit value to the byte array +XED_DLL_EXPORT void +xed_immdis_add8(xed_immdis_t* p, xed_int8_t d); + +/// add a 16 bit value to the byte array +XED_DLL_EXPORT void +xed_immdis_add16(xed_immdis_t* p, xed_int16_t d); + +/// add a 32 bit value to the byte array +XED_DLL_EXPORT void +xed_immdis_add32(xed_immdis_t* p, xed_int32_t d); + +/// add a 64 bit value to the byte array. +XED_DLL_EXPORT void +xed_immdis_add64(xed_immdis_t* p, xed_int64_t d); + +//@} + + +/// @name printing / debugging +//@{ + +/// just print the raw bytes in hex with a leading 0x +XED_DLL_EXPORT int xed_immdis_print(const xed_immdis_t* p, char* buf, int buflen); + +/// Print the value as a signed or unsigned number depending on the +/// value of the immediate_is_unsigned variable. +XED_DLL_EXPORT int +xed_immdis_print_signed_or_unsigned(const xed_immdis_t* p, char* buf, int buflen); + +/// print the signed value, appropriate width, with a leading 0x +XED_DLL_EXPORT int +xed_immdis_print_value_signed(const xed_immdis_t* p, char* buf, int buflen); + +/// print the unsigned value, appropriate width, with a leading 0x +XED_DLL_EXPORT int +xed_immdis_print_value_unsigned(const xed_immdis_t* p, char* buf, int buflen); + +int xed_immdis__print_ptr(const xed_immdis_t* p, char* buf, int buflen); +#endif + +//@} + + diff --git a/third_party/xed-intel64/include/xed-immed.h b/third_party/xed-intel64/include/xed-immed.h new file mode 100644 index 0000000..daa7e27 --- /dev/null +++ b/third_party/xed-intel64/include/xed-immed.h @@ -0,0 +1,62 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-immed.h +/// + +#ifndef _XED_IMMED_H_ +# define _XED_IMMED_H_ + +#include "../../../third_party/xed-intel64/include/xed-common-defs.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" +#include "../../../third_party/xed-intel64/include/xed-util.h" + +XED_DLL_EXPORT xed_int64_t xed_immed_from_bytes(xed_int8_t* bytes, xed_uint_t n); + /* + Convert an array of bytes representing a Little Endian byte ordering + of a number (11 22 33 44 55.. 88), in to a a 64b SIGNED number. That gets + stored in memory in little endian format of course. + + Input 11 22 33 44 55 66 77 88, 8 + Ouptut 0x8877665544332211 (stored in memory as (lsb) 11 22 33 44 55 66 77 88 (msb)) + + Input f0, 1 + Output 0xffff_ffff_ffff_fff0 (stored in memory as f0 ff ff ff ff ff ff ff) + + Input f0 00, 2 + Output 0x0000_0000_0000_00F0 (stored in memory a f0 00 00 00 00 00 00 00) + + Input 03, 1 + Output 0x0000_0000_0000_0030 (stored in memory a 30 00 00 00 00 00 00 00) + */ + + +#endif diff --git a/third_party/xed-intel64/include/xed-init-pointer-names.h b/third_party/xed-intel64/include/xed-init-pointer-names.h new file mode 100644 index 0000000..5460135 --- /dev/null +++ b/third_party/xed-intel64/include/xed-init-pointer-names.h @@ -0,0 +1,41 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-init-pointer-names.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_INIT_POINTER_NAMES_H_) +# define _XED_INIT_POINTER_NAMES_H_ +#include "xed-internal-header.h" +#define XED_MAX_POINTER_NAMES 65 +#endif diff --git a/third_party/xed-intel64/include/xed-init.h b/third_party/xed-intel64/include/xed-init.h new file mode 100644 index 0000000..52fa12c --- /dev/null +++ b/third_party/xed-intel64/include/xed-init.h @@ -0,0 +1,49 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-init.h +/// + + + + +#if !defined(_XED_INIT_H_) +# define _XED_INIT_H_ + + +/// @ingroup INIT +/// This is the call to initialize the XED encode and decode tables. It +/// must be called once before using XED. +void XED_DLL_EXPORT xed_tables_init(void); + +//////////////////////////////////////////////////////////////////////////// + +#endif diff --git a/third_party/xed-intel64/include/xed-inst.h b/third_party/xed-intel64/include/xed-inst.h new file mode 100644 index 0000000..d1511d8 --- /dev/null +++ b/third_party/xed-intel64/include/xed-inst.h @@ -0,0 +1,380 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-inst.h + + +#if !defined(_XED_INST_H_) +# define _XED_INST_H_ + +#include "../../../third_party/xed-intel64/include/xed-attribute-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-attributes.h" +#include "../../../third_party/xed-intel64/include/xed-category-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-exception-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-extension-enum.h" //generated +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" //generated +#include "../../../third_party/xed-intel64/include/xed-iform-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-iform-map.h" +#include "../../../third_party/xed-intel64/include/xed-nonterminal-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-operand-action-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-operand-convert-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-operand-element-xtype-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-operand-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-operand-type-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-operand-visibility-enum.h" //generated +#include "../../../third_party/xed-intel64/include/xed-operand-width-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-reg-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-util.h" + +struct xed_decoded_inst_s; //fwd-decl + +typedef void (*xed_operand_extractor_fn_t)(struct xed_decoded_inst_s* xds); + + +/// @ingroup DEC +/// Constant information about an individual generic operand, like an +///operand template, describing the operand properties. See @ref DEC for +///API information. +typedef struct xed_operand_s +{ + xed_operand_enum_t _name; + + // implicit, explicit, suppressed + xed_operand_visibility_enum_t _operand_visibility; + xed_operand_action_enum_t _rw; // read or written + + // width code, could be invalid (then use register name) + xed_operand_width_enum_t _oc2; + + // IMM, IMM_CONST, NT_LOOKUP_FN, REG, ERROR + xed_operand_type_enum_t _type; + xed_operand_element_xtype_enum_t _xtype; // xed data type: u32, f32, etc. + xed_uint8_t _cvt_idx; // decoration index + union { + xed_uint32_t _imm; // value for some constant immmed + xed_nonterminal_enum_t _nt; // for nt_lookup_fn's + xed_reg_enum_t _reg; // register name + } _u; +} xed_operand_t; + +/// @name xed_inst_t Template Operands Access +//@{ +/// @ingroup DEC +static XED_INLINE xed_operand_enum_t +xed_operand_name(const xed_operand_t* p) { + return p->_name; +} + + +/// @ingroup DEC +static XED_INLINE xed_operand_visibility_enum_t +xed_operand_operand_visibility( const xed_operand_t* p) { + return p->_operand_visibility; +} + + +/// @ingroup DEC +/// @return The #xed_operand_type_enum_t of the operand template. +/// This is probably not what you want. +static XED_INLINE xed_operand_type_enum_t +xed_operand_type(const xed_operand_t* p) { + return p->_type; +} + +/// @ingroup DEC +/// @return The #xed_operand_element_xtype_enum_t of the operand template. +/// This is probably not what you want. +static XED_INLINE xed_operand_element_xtype_enum_t +xed_operand_xtype(const xed_operand_t* p) { + return p->_xtype; +} + + +/// @ingroup DEC +static XED_INLINE xed_operand_width_enum_t +xed_operand_width(const xed_operand_t* p) { + return p->_oc2; +} + +/// @ingroup DEC +/// @param p an operand template, #xed_operand_t. +/// @param eosz effective operand size of the instruction, 1 | 2 | 3 for +/// 16 | 32 | 64 bits respectively. 0 is invalid. +/// @return the actual width of operand in bits. +/// See xed_decoded_inst_operand_length_bits() for a more general solution. +XED_DLL_EXPORT xed_uint32_t +xed_operand_width_bits(const xed_operand_t* p, + const xed_uint32_t eosz); + +/// @ingroup DEC +static XED_INLINE xed_nonterminal_enum_t +xed_operand_nonterminal_name(const xed_operand_t* p) { + if (xed_operand_type(p) == XED_OPERAND_TYPE_NT_LOOKUP_FN) + return p->_u._nt; + return XED_NONTERMINAL_INVALID; +} + +/// @ingroup DEC +/// Careful with this one -- use #xed_decoded_inst_get_reg()! This one is +/// probably not what you think it is. It is only used for hard-coded +/// registers implicit in the instruction encoding. Most likely you want to +/// get the #xed_operand_enum_t and then look up the instruction using +/// #xed_decoded_inst_get_reg(). The hard-coded registers are also available +/// that way. +/// @param p an operand template, #xed_operand_t. +/// @return the implicit or suppressed registers, type #xed_reg_enum_t +static XED_INLINE xed_reg_enum_t xed_operand_reg(const xed_operand_t* p) { + if (xed_operand_type(p) == XED_OPERAND_TYPE_REG) + return p->_u._reg; + return XED_REG_INVALID; +} + + + +/// @ingroup DEC +/// Careful with this one; See #xed_operand_is_register(). +/// @param p an operand template, #xed_operand_t. +/// @return 1 if the operand template represents are register-type +/// operand. +/// +/// Related functions: +/// Use #xed_decoded_inst_get_reg() to get the decoded name of /// the +/// register, #xed_reg_enum_t. Use #xed_operand_is_register() to test +/// #xed_operand_enum_t names. +static XED_INLINE xed_uint_t +xed_operand_template_is_register(const xed_operand_t* p) { + return p->_type == XED_OPERAND_TYPE_NT_LOOKUP_FN || + p->_type == XED_OPERAND_TYPE_REG; +} + +/// @ingroup DEC +/// @param p an operand template, #xed_operand_t. +/// These operands represent branch displacements, memory displacements and +/// various immediates +static XED_INLINE xed_uint32_t xed_operand_imm(const xed_operand_t* p) { + if (xed_operand_type(p) == XED_OPERAND_TYPE_IMM_CONST) + return p->_u._imm; + return 0; +} + +/// @ingroup DEC +/// Print the operand p into the buffer buf, of length buflen. +/// @param p an operand template, #xed_operand_t. +/// @param buf buffer that gets filled in +/// @param buflen maximum buffer length +XED_DLL_EXPORT void +xed_operand_print(const xed_operand_t* p, char* buf, int buflen); +//@} + +/// @name xed_inst_t Template Operand Enum Name Classification +//@{ +/// @ingroup DEC +/// Tests the enum for inclusion in XED_OPERAND_REG0 through XED_OPERAND_REG15. +/// @param name the operand name, type #xed_operand_enum_t +/// @return 1 if the operand name is REG0...REG15, 0 otherwise. +/// +///Note there are other registers for memory addressing; See +/// #xed_operand_is_memory_addressing_register . +static XED_INLINE xed_uint_t xed_operand_is_register(xed_operand_enum_t name) { + return name >= XED_OPERAND_REG0 && name <= XED_OPERAND_REG8; +} +/// @ingroup DEC +/// Tests the enum for inclusion in XED_OPERAND_{BASE0,BASE1,INDEX,SEG0,SEG1} +/// @param name the operand name, type #xed_operand_enum_t +/// @return 1 if the operand name is for a memory addressing register operand, 0 +/// otherwise. See also #xed_operand_is_register . +static XED_INLINE xed_uint_t +xed_operand_is_memory_addressing_register(xed_operand_enum_t name) { + return ( name == XED_OPERAND_BASE0 || + name == XED_OPERAND_INDEX || + name == XED_OPERAND_SEG0 || + name == XED_OPERAND_BASE1 || + name == XED_OPERAND_SEG1 ); +} + +//@} + +/// @name xed_inst_t Template Operand Read/Written +//@{ +/// @ingroup DEC +/// DEPRECATED: Returns the raw R/W action. There are many cases for conditional reads +/// and writes. See #xed_decoded_inst_operand_action(). +static XED_INLINE xed_operand_action_enum_t +xed_operand_rw(const xed_operand_t* p) { + return p->_rw; +} + +/// @ingroup DEC +/// If the operand is read, including conditional reads +XED_DLL_EXPORT xed_uint_t xed_operand_read(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand is read-only, including conditional reads +XED_DLL_EXPORT xed_uint_t xed_operand_read_only(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand is written, including conditional writes +XED_DLL_EXPORT xed_uint_t xed_operand_written(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand is written-only, including conditional writes +XED_DLL_EXPORT xed_uint_t xed_operand_written_only(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand is read-and-written, conditional reads and conditional writes +XED_DLL_EXPORT xed_uint_t xed_operand_read_and_written(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand has a conditional read (may also write) +XED_DLL_EXPORT xed_uint_t xed_operand_conditional_read(const xed_operand_t* p); +/// @ingroup DEC +/// If the operand has a conditional write (may also read) +XED_DLL_EXPORT xed_uint_t xed_operand_conditional_write(const xed_operand_t* p); +//@} + + +/// @ingroup DEC +/// constant information about a decoded instruction form, including +/// the pointer to the constant operand properties #xed_operand_t for this +/// instruction form. +typedef struct xed_inst_s { + + + // rflags info -- index in to the 2 tables of flags information. + // If _flag_complex is true, then the data are in the + // xed_flags_complex_table[]. Otherwise, the data are in the + // xed_flags_simple_table[]. + + //xed_instruction_fixed_bit_confirmer_fn_t _confirmer; + + // number of operands in the operands array + xed_uint8_t _noperands; + xed_uint8_t _cpl; // the nominal CPL for the instruction. + xed_uint16_t _flag_info_index; + + xed_iform_enum_t _iform_enum; + // index into the xed_operand[] array of xed_operand_t structures + xed_uint16_t _operand_base; + xed_uint16_t _flag_complex; /* 1/0 valued, bool type */ + + // index to table of xed_attributes_t structures + xed_uint16_t _attributes; + xed_exception_enum_t _exceptions; +} xed_inst_t; + +/// @name xed_inst_t Template Instruction Information +//@{ +/// @ingroup DEC +/// xed_inst_cpl() is DEPRECATED. Please use +/// "xed_decoded_inst_get_attribute(xedd, XED_ATTRIBUTE_RING0)" +/// instead. +///Return the current privilege level (CPL) required for execution, 0 or +///3. If the value is zero, then the instruction can only execute in ring 0. +XED_DLL_EXPORT unsigned int xed_inst_cpl(const xed_inst_t* p) ; + + +//These next few are not doxygen commented because I want people to use the +//higher level interface in xed-decoded-inst.h. +static XED_INLINE xed_iclass_enum_t xed_inst_iclass(const xed_inst_t* p) { + return xed_iform_to_iclass(p->_iform_enum); +} + +static XED_INLINE xed_category_enum_t xed_inst_category(const xed_inst_t* p) { + return xed_iform_to_category(p->_iform_enum); +} + +static XED_INLINE xed_extension_enum_t xed_inst_extension(const xed_inst_t* p) { + return xed_iform_to_extension(p->_iform_enum); +} +static XED_INLINE xed_isa_set_enum_t xed_inst_isa_set(const xed_inst_t* p) { + return xed_iform_to_isa_set(p->_iform_enum); +} + +static XED_INLINE xed_iform_enum_t xed_inst_iform_enum(const xed_inst_t* p) { + return p->_iform_enum; +} + + +///@ingroup DEC +/// Number of instruction operands +static XED_INLINE unsigned int xed_inst_noperands(const xed_inst_t* p) { + return p->_noperands; +} + +///@ingroup DEC +/// Obtain a pointer to an individual operand +XED_DLL_EXPORT const xed_operand_t* +xed_inst_operand(const xed_inst_t* p, unsigned int i); + + + +XED_DLL_EXPORT xed_uint32_t xed_inst_flag_info_index(const xed_inst_t* p); + +//@} + +/// @name xed_inst_t Attribute access +//@{ +/// @ingroup DEC +/// Scan for the attribute attr and return 1 if it is found, 0 otherwise. +XED_DLL_EXPORT xed_uint32_t +xed_inst_get_attribute(const xed_inst_t* p, + xed_attribute_enum_t attr); + +/// @ingroup DEC +/// Return the attributes bit vector +XED_DLL_EXPORT xed_attributes_t +xed_inst_get_attributes(const xed_inst_t* p); + + +/// @ingroup DEC +/// Return the maximum number of defined attributes, independent of any +/// instruction. +XED_DLL_EXPORT unsigned int xed_attribute_max(void); + +/// @ingroup DEC +/// Return the i'th global attribute in a linear sequence, independent of +/// any instruction. This is used for scanning and printing all attributes. +XED_DLL_EXPORT xed_attribute_enum_t xed_attribute(unsigned int i); + +//@} + +/// @name Exceptions +//@{ +/// @ingroup DEC +/// Return #xed_exception_enum_t if present for the specified instruction. +/// This is currently only used for SSE and AVX instructions. +static XED_INLINE +xed_exception_enum_t xed_inst_exception(const xed_inst_t* p) { + return p->_exceptions; +} + +//@} +/// @ingroup DEC +/// Return the base of instruction table. +XED_DLL_EXPORT const xed_inst_t* xed_inst_table_base(void); + +#endif diff --git a/third_party/xed-intel64/include/xed-interface.h b/third_party/xed-intel64/include/xed-interface.h new file mode 100644 index 0000000..0829661 --- /dev/null +++ b/third_party/xed-intel64/include/xed-interface.h @@ -0,0 +1,95 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/* +/// @file xed-interface.h +/// +*/ + + + +#if !defined(_XED_INTERFACE_H_) +# define _XED_INTERFACE_H_ + +#if defined(_WIN32) && defined(_MANAGED) +#pragma unmanaged +#endif + +#include "../../../third_party/xed-intel64/include/xed-build-defines.h" /* generated */ + +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" +#include "../../../third_party/xed-intel64/include/xed-operand-enum.h" + +#include "../../../third_party/xed-intel64/include/xed-init.h" +#include "../../../third_party/xed-intel64/include/xed-decode.h" +#include "../../../third_party/xed-intel64/include/xed-ild.h" + +#include "../../../third_party/xed-intel64/include/xed-state.h" /* dstate, legacy */ +#include "../../../third_party/xed-intel64/include/xed-syntax-enum.h" +#include "../../../third_party/xed-intel64/include/xed-reg-class-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-reg-class.h" + +#if defined(XED_ENCODER) +# include "../../../third_party/xed-intel64/include/xed-encode.h" +# include "../../../third_party/xed-intel64/include/xed-encoder-hl.h" +#endif +#include "../../../third_party/xed-intel64/include/xed-util.h" +#include "../../../third_party/xed-intel64/include/xed-operand-action.h" + +#include "../../../third_party/xed-intel64/include/xed-version.h" +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-decoded-inst-api.h" +#include "../../../third_party/xed-intel64/include/xed-inst.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-category-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-extension-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-attribute-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-exception-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-operand-element-type-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-operand-element-xtype-enum.h" /* generated */ + +#include "../../../third_party/xed-intel64/include/xed-disas.h" // callbacks for disassembly +#include "../../../third_party/xed-intel64/include/xed-format-options.h" /* options for disassembly */ + +#include "../../../third_party/xed-intel64/include/xed-iform-enum.h" /* generated */ +/* indicates the first and last index of each iform, for building tables */ +#include "../../../third_party/xed-intel64/include/xed-iformfl-enum.h" /* generated */ +/* mapping iforms to iclass/category/extension */ +#include "../../../third_party/xed-intel64/include/xed-iform-map.h" +#include "../../../third_party/xed-intel64/include/xed-rep-prefix.h" + + +#include "../../../third_party/xed-intel64/include/xed-agen.h" +#include "../../../third_party/xed-intel64/include/xed-cpuid-rec.h" + + +#endif diff --git a/third_party/xed-intel64/include/xed-isa-set-enum.h b/third_party/xed-intel64/include/xed-isa-set-enum.h new file mode 100644 index 0000000..37967e6 --- /dev/null +++ b/third_party/xed-intel64/include/xed-isa-set-enum.h @@ -0,0 +1,159 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-isa-set-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_ISA_SET_ENUM_H_) +# define _XED_ISA_SET_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_ISA_SET_INVALID, + XED_ISA_SET_3DNOW, + XED_ISA_SET_AES, + XED_ISA_SET_AMD, + XED_ISA_SET_AVX, + XED_ISA_SET_AVX2, + XED_ISA_SET_AVX2GATHER, + XED_ISA_SET_AVX512BW_128, + XED_ISA_SET_AVX512BW_128N, + XED_ISA_SET_AVX512BW_256, + XED_ISA_SET_AVX512BW_512, + XED_ISA_SET_AVX512BW_KOP, + XED_ISA_SET_AVX512CD_128, + XED_ISA_SET_AVX512CD_256, + XED_ISA_SET_AVX512CD_512, + XED_ISA_SET_AVX512DQ_128, + XED_ISA_SET_AVX512DQ_128N, + XED_ISA_SET_AVX512DQ_256, + XED_ISA_SET_AVX512DQ_512, + XED_ISA_SET_AVX512DQ_KOP, + XED_ISA_SET_AVX512DQ_SCALAR, + XED_ISA_SET_AVX512ER_512, + XED_ISA_SET_AVX512ER_SCALAR, + XED_ISA_SET_AVX512F_128, + XED_ISA_SET_AVX512F_128N, + XED_ISA_SET_AVX512F_256, + XED_ISA_SET_AVX512F_512, + XED_ISA_SET_AVX512F_KOP, + XED_ISA_SET_AVX512F_SCALAR, + XED_ISA_SET_AVX512IFMA_128, + XED_ISA_SET_AVX512IFMA_256, + XED_ISA_SET_AVX512IFMA_512, + XED_ISA_SET_AVX512PF_512, + XED_ISA_SET_AVX512VBMI_128, + XED_ISA_SET_AVX512VBMI_256, + XED_ISA_SET_AVX512VBMI_512, + XED_ISA_SET_AVXAES, + XED_ISA_SET_BDW, + XED_ISA_SET_BMI1, + XED_ISA_SET_BMI2, + XED_ISA_SET_CLFLUSHOPT, + XED_ISA_SET_CLFSH, + XED_ISA_SET_CLWB, + XED_ISA_SET_CMPXCHG16B, + XED_ISA_SET_F16C, + XED_ISA_SET_FMA, + XED_ISA_SET_FMA4, + XED_ISA_SET_FXSAVE, + XED_ISA_SET_FXSAVE64, + XED_ISA_SET_I186, + XED_ISA_SET_I286PROTECTED, + XED_ISA_SET_I286REAL, + XED_ISA_SET_I386, + XED_ISA_SET_I486, + XED_ISA_SET_I486REAL, + XED_ISA_SET_I86, + XED_ISA_SET_INVPCID, + XED_ISA_SET_LAHF, + XED_ISA_SET_LONGMODE, + XED_ISA_SET_LZCNT, + XED_ISA_SET_MOVBE, + XED_ISA_SET_MPX, + XED_ISA_SET_PAUSE, + XED_ISA_SET_PCLMULQDQ, + XED_ISA_SET_PCOMMIT, + XED_ISA_SET_PENTIUMMMX, + XED_ISA_SET_PENTIUMREAL, + XED_ISA_SET_POPCNT, + XED_ISA_SET_PPRO, + XED_ISA_SET_PREFETCHW, + XED_ISA_SET_PREFETCHWT1, + XED_ISA_SET_PREFETCH_NOP, + XED_ISA_SET_RDPMC, + XED_ISA_SET_RDRAND, + XED_ISA_SET_RDSEED, + XED_ISA_SET_RDTSCP, + XED_ISA_SET_RDWRFSGS, + XED_ISA_SET_RTM, + XED_ISA_SET_SGX, + XED_ISA_SET_SHA, + XED_ISA_SET_SMAP, + XED_ISA_SET_SMX, + XED_ISA_SET_SSE, + XED_ISA_SET_SSE2, + XED_ISA_SET_SSE3, + XED_ISA_SET_SSE4, + XED_ISA_SET_SSE42, + XED_ISA_SET_SSE4A, + XED_ISA_SET_SSEMXCSR, + XED_ISA_SET_SSSE3, + XED_ISA_SET_SVM, + XED_ISA_SET_TBM, + XED_ISA_SET_VMFUNC, + XED_ISA_SET_VTX, + XED_ISA_SET_X87, + XED_ISA_SET_XOP, + XED_ISA_SET_XSAVE, + XED_ISA_SET_XSAVEC, + XED_ISA_SET_XSAVEOPT, + XED_ISA_SET_XSAVES, + XED_ISA_SET_LAST +} xed_isa_set_enum_t; + +/// This converts strings to #xed_isa_set_enum_t types. +/// @param s A C-string. +/// @return #xed_isa_set_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_isa_set_enum_t str2xed_isa_set_enum_t(const char* s); +/// This converts strings to #xed_isa_set_enum_t types. +/// @param p An enumeration element of type xed_isa_set_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_isa_set_enum_t2str(const xed_isa_set_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_isa_set_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_isa_set_enum_t xed_isa_set_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-isa-set.h b/third_party/xed-intel64/include/xed-isa-set.h new file mode 100644 index 0000000..27b08f7 --- /dev/null +++ b/third_party/xed-intel64/include/xed-isa-set.h @@ -0,0 +1,51 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-isa-set.h + + +#if !defined(_XED_ISA_SET_H_) +# define _XED_ISA_SET_H_ + +#include "../../../third_party/xed-intel64/include/xed-chip-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-isa-set-enum.h" /* generated */ +#include "../../../third_party/xed-intel64/include/xed-types.h" + +/// @ingroup ISASET +/// return 1 if the isa_set is part included in the specified chip, 0 +/// otherwise. +XED_DLL_EXPORT xed_bool_t +xed_isa_set_is_valid_for_chip(xed_isa_set_enum_t isa_set, + xed_chip_enum_t chip); + + +#endif diff --git a/third_party/xed-intel64/include/xed-machine-mode-enum.h b/third_party/xed-intel64/include/xed-machine-mode-enum.h new file mode 100644 index 0000000..647d6f1 --- /dev/null +++ b/third_party/xed-intel64/include/xed-machine-mode-enum.h @@ -0,0 +1,66 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-machine-mode-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_MACHINE_MODE_ENUM_H_) +# define _XED_MACHINE_MODE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_MACHINE_MODE_INVALID, + XED_MACHINE_MODE_LONG_64, ///< 64b operating mode + XED_MACHINE_MODE_LONG_COMPAT_32, ///< 32b protected mode + XED_MACHINE_MODE_LONG_COMPAT_16, ///< 16b protected mode + XED_MACHINE_MODE_LEGACY_32, ///< 32b protected mode + XED_MACHINE_MODE_LEGACY_16, ///< 16b protected mode + XED_MACHINE_MODE_REAL_16, ///< 16b real mode + XED_MACHINE_MODE_LAST +} xed_machine_mode_enum_t; + +/// This converts strings to #xed_machine_mode_enum_t types. +/// @param s A C-string. +/// @return #xed_machine_mode_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_machine_mode_enum_t str2xed_machine_mode_enum_t(const char* s); +/// This converts strings to #xed_machine_mode_enum_t types. +/// @param p An enumeration element of type xed_machine_mode_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_machine_mode_enum_t2str(const xed_machine_mode_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_machine_mode_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_machine_mode_enum_t xed_machine_mode_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-nonterminal-enum.h b/third_party/xed-intel64/include/xed-nonterminal-enum.h new file mode 100644 index 0000000..11e56b5 --- /dev/null +++ b/third_party/xed-intel64/include/xed-nonterminal-enum.h @@ -0,0 +1,310 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-nonterminal-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_NONTERMINAL_ENUM_H_) +# define _XED_NONTERMINAL_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_NONTERMINAL_INVALID, + XED_NONTERMINAL_AR10, + XED_NONTERMINAL_AR11, + XED_NONTERMINAL_AR12, + XED_NONTERMINAL_AR13, + XED_NONTERMINAL_AR14, + XED_NONTERMINAL_AR15, + XED_NONTERMINAL_AR8, + XED_NONTERMINAL_AR9, + XED_NONTERMINAL_ARAX, + XED_NONTERMINAL_ARBP, + XED_NONTERMINAL_ARBX, + XED_NONTERMINAL_ARCX, + XED_NONTERMINAL_ARDI, + XED_NONTERMINAL_ARDX, + XED_NONTERMINAL_ARSI, + XED_NONTERMINAL_ARSP, + XED_NONTERMINAL_ASZ_NONTERM, + XED_NONTERMINAL_AVX512_ROUND, + XED_NONTERMINAL_AVX_INSTRUCTIONS, + XED_NONTERMINAL_AVX_SPLITTER, + XED_NONTERMINAL_BND_B, + XED_NONTERMINAL_BND_B_CHECK, + XED_NONTERMINAL_BND_R, + XED_NONTERMINAL_BND_R_CHECK, + XED_NONTERMINAL_BRANCH_HINT, + XED_NONTERMINAL_BRDISP32, + XED_NONTERMINAL_BRDISP8, + XED_NONTERMINAL_BRDISPZ, + XED_NONTERMINAL_CR_B, + XED_NONTERMINAL_CR_R, + XED_NONTERMINAL_CR_WIDTH, + XED_NONTERMINAL_DF64, + XED_NONTERMINAL_DR_B, + XED_NONTERMINAL_DR_R, + XED_NONTERMINAL_ESIZE_128_BITS, + XED_NONTERMINAL_ESIZE_16_BITS, + XED_NONTERMINAL_ESIZE_1_BITS, + XED_NONTERMINAL_ESIZE_2_BITS, + XED_NONTERMINAL_ESIZE_32_BITS, + XED_NONTERMINAL_ESIZE_4_BITS, + XED_NONTERMINAL_ESIZE_64_BITS, + XED_NONTERMINAL_ESIZE_8_BITS, + XED_NONTERMINAL_EVEX_INSTRUCTIONS, + XED_NONTERMINAL_EVEX_SPLITTER, + XED_NONTERMINAL_FINAL_DSEG, + XED_NONTERMINAL_FINAL_DSEG1, + XED_NONTERMINAL_FINAL_DSEG1_MODE64, + XED_NONTERMINAL_FINAL_DSEG1_NOT64, + XED_NONTERMINAL_FINAL_DSEG_MODE64, + XED_NONTERMINAL_FINAL_DSEG_NOT64, + XED_NONTERMINAL_FINAL_ESEG, + XED_NONTERMINAL_FINAL_ESEG1, + XED_NONTERMINAL_FINAL_SSEG, + XED_NONTERMINAL_FINAL_SSEG0, + XED_NONTERMINAL_FINAL_SSEG1, + XED_NONTERMINAL_FINAL_SSEG_MODE64, + XED_NONTERMINAL_FINAL_SSEG_NOT64, + XED_NONTERMINAL_FIX_ROUND_LEN128, + XED_NONTERMINAL_FIX_ROUND_LEN512, + XED_NONTERMINAL_FORCE64, + XED_NONTERMINAL_GPR16_B, + XED_NONTERMINAL_GPR16_R, + XED_NONTERMINAL_GPR16_SB, + XED_NONTERMINAL_GPR16_SR, + XED_NONTERMINAL_GPR32_B, + XED_NONTERMINAL_GPR32_R, + XED_NONTERMINAL_GPR32_SB, + XED_NONTERMINAL_GPR32_SR, + XED_NONTERMINAL_GPR32_X, + XED_NONTERMINAL_GPR64_B, + XED_NONTERMINAL_GPR64_R, + XED_NONTERMINAL_GPR64_SB, + XED_NONTERMINAL_GPR64_SR, + XED_NONTERMINAL_GPR64_X, + XED_NONTERMINAL_GPR8_B, + XED_NONTERMINAL_GPR8_R, + XED_NONTERMINAL_GPR8_SB, + XED_NONTERMINAL_GPR8_SR, + XED_NONTERMINAL_GPRM_B, + XED_NONTERMINAL_GPRM_R, + XED_NONTERMINAL_GPRV_B, + XED_NONTERMINAL_GPRV_R, + XED_NONTERMINAL_GPRV_SB, + XED_NONTERMINAL_GPRV_SR, + XED_NONTERMINAL_GPRY_B, + XED_NONTERMINAL_GPRY_N, + XED_NONTERMINAL_GPRY_R, + XED_NONTERMINAL_GPRZ_B, + XED_NONTERMINAL_GPRZ_R, + XED_NONTERMINAL_IGNORE66, + XED_NONTERMINAL_IMMUNE66, + XED_NONTERMINAL_IMMUNE66_LOOP64, + XED_NONTERMINAL_IMMUNE_REXW, + XED_NONTERMINAL_INSTRUCTIONS, + XED_NONTERMINAL_ISA, + XED_NONTERMINAL_MASK1, + XED_NONTERMINAL_MASK_B, + XED_NONTERMINAL_MASK_I3, + XED_NONTERMINAL_MASK_N, + XED_NONTERMINAL_MASK_R, + XED_NONTERMINAL_MEMDISP, + XED_NONTERMINAL_MEMDISP16, + XED_NONTERMINAL_MEMDISP32, + XED_NONTERMINAL_MEMDISP8, + XED_NONTERMINAL_MEMDISPV, + XED_NONTERMINAL_MMX_B, + XED_NONTERMINAL_MMX_R, + XED_NONTERMINAL_MODRM, + XED_NONTERMINAL_MODRM16, + XED_NONTERMINAL_MODRM32, + XED_NONTERMINAL_MODRM64ALT32, + XED_NONTERMINAL_NELEM_EIGHTHMEM, + XED_NONTERMINAL_NELEM_FULL, + XED_NONTERMINAL_NELEM_FULLMEM, + XED_NONTERMINAL_NELEM_GPR_READER, + XED_NONTERMINAL_NELEM_GPR_READER_BYTE, + XED_NONTERMINAL_NELEM_GPR_READER_SUBDWORD, + XED_NONTERMINAL_NELEM_GPR_READER_WORD, + XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP, + XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_D, + XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_Q, + XED_NONTERMINAL_NELEM_GPR_WRITER_STORE, + XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_BYTE, + XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_SUBDWORD, + XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_WORD, + XED_NONTERMINAL_NELEM_GSCAT, + XED_NONTERMINAL_NELEM_HALF, + XED_NONTERMINAL_NELEM_HALFMEM, + XED_NONTERMINAL_NELEM_MEM128, + XED_NONTERMINAL_NELEM_MOVDDUP, + XED_NONTERMINAL_NELEM_QUARTERMEM, + XED_NONTERMINAL_NELEM_SCALAR, + XED_NONTERMINAL_NELEM_TUPLE1, + XED_NONTERMINAL_NELEM_TUPLE1_BYTE, + XED_NONTERMINAL_NELEM_TUPLE1_SUBDWORD, + XED_NONTERMINAL_NELEM_TUPLE1_WORD, + XED_NONTERMINAL_NELEM_TUPLE2, + XED_NONTERMINAL_NELEM_TUPLE4, + XED_NONTERMINAL_NELEM_TUPLE8, + XED_NONTERMINAL_OEAX, + XED_NONTERMINAL_ONE, + XED_NONTERMINAL_ORAX, + XED_NONTERMINAL_ORBP, + XED_NONTERMINAL_ORDX, + XED_NONTERMINAL_ORSP, + XED_NONTERMINAL_OSZ_NONTERM, + XED_NONTERMINAL_OVERRIDE_SEG0, + XED_NONTERMINAL_OVERRIDE_SEG1, + XED_NONTERMINAL_PREFIXES, + XED_NONTERMINAL_REFINING66, + XED_NONTERMINAL_REMOVE_SEGMENT, + XED_NONTERMINAL_RFLAGS, + XED_NONTERMINAL_RIP, + XED_NONTERMINAL_SAE, + XED_NONTERMINAL_SEG, + XED_NONTERMINAL_SE_IMM8, + XED_NONTERMINAL_SIB, + XED_NONTERMINAL_SIB_BASE0, + XED_NONTERMINAL_SIMM8, + XED_NONTERMINAL_SIMMZ, + XED_NONTERMINAL_SRBP, + XED_NONTERMINAL_SRSP, + XED_NONTERMINAL_UIMM16, + XED_NONTERMINAL_UIMM32, + XED_NONTERMINAL_UIMM8, + XED_NONTERMINAL_UIMM8_1, + XED_NONTERMINAL_UIMMV, + XED_NONTERMINAL_UISA_SE_IMM8, + XED_NONTERMINAL_UISA_VMODRM_XMM, + XED_NONTERMINAL_UISA_VMODRM_YMM, + XED_NONTERMINAL_UISA_VMODRM_ZMM, + XED_NONTERMINAL_UISA_VSIB_BASE, + XED_NONTERMINAL_UISA_VSIB_INDEX_XMM, + XED_NONTERMINAL_UISA_VSIB_INDEX_YMM, + XED_NONTERMINAL_UISA_VSIB_INDEX_ZMM, + XED_NONTERMINAL_UISA_VSIB_XMM, + XED_NONTERMINAL_UISA_VSIB_YMM, + XED_NONTERMINAL_UISA_VSIB_ZMM, + XED_NONTERMINAL_VGPR32_B, + XED_NONTERMINAL_VGPR32_B_32, + XED_NONTERMINAL_VGPR32_B_64, + XED_NONTERMINAL_VGPR32_N, + XED_NONTERMINAL_VGPR32_N_32, + XED_NONTERMINAL_VGPR32_N_64, + XED_NONTERMINAL_VGPR32_R, + XED_NONTERMINAL_VGPR32_R_32, + XED_NONTERMINAL_VGPR32_R_64, + XED_NONTERMINAL_VGPR64_B, + XED_NONTERMINAL_VGPR64_N, + XED_NONTERMINAL_VGPR64_R, + XED_NONTERMINAL_VGPRV_N, + XED_NONTERMINAL_VMODRM_XMM, + XED_NONTERMINAL_VMODRM_YMM, + XED_NONTERMINAL_VSIB_BASE, + XED_NONTERMINAL_VSIB_INDEX_XMM, + XED_NONTERMINAL_VSIB_INDEX_YMM, + XED_NONTERMINAL_VSIB_XMM, + XED_NONTERMINAL_VSIB_YMM, + XED_NONTERMINAL_X87, + XED_NONTERMINAL_XMM_B, + XED_NONTERMINAL_XMM_B3, + XED_NONTERMINAL_XMM_B_32, + XED_NONTERMINAL_XMM_B_64, + XED_NONTERMINAL_XMM_I3, + XED_NONTERMINAL_XMM_N, + XED_NONTERMINAL_XMM_N3, + XED_NONTERMINAL_XMM_N3_32, + XED_NONTERMINAL_XMM_N3_64, + XED_NONTERMINAL_XMM_N_32, + XED_NONTERMINAL_XMM_N_64, + XED_NONTERMINAL_XMM_R, + XED_NONTERMINAL_XMM_R3, + XED_NONTERMINAL_XMM_R3_32, + XED_NONTERMINAL_XMM_R3_64, + XED_NONTERMINAL_XMM_R_32, + XED_NONTERMINAL_XMM_R_64, + XED_NONTERMINAL_XMM_SE, + XED_NONTERMINAL_XMM_SE32, + XED_NONTERMINAL_XMM_SE64, + XED_NONTERMINAL_XOP_INSTRUCTIONS, + XED_NONTERMINAL_YMM_B, + XED_NONTERMINAL_YMM_B3, + XED_NONTERMINAL_YMM_B_32, + XED_NONTERMINAL_YMM_B_64, + XED_NONTERMINAL_YMM_I3, + XED_NONTERMINAL_YMM_N, + XED_NONTERMINAL_YMM_N3, + XED_NONTERMINAL_YMM_N3_32, + XED_NONTERMINAL_YMM_N3_64, + XED_NONTERMINAL_YMM_N_32, + XED_NONTERMINAL_YMM_N_64, + XED_NONTERMINAL_YMM_R, + XED_NONTERMINAL_YMM_R3, + XED_NONTERMINAL_YMM_R3_32, + XED_NONTERMINAL_YMM_R3_64, + XED_NONTERMINAL_YMM_R_32, + XED_NONTERMINAL_YMM_R_64, + XED_NONTERMINAL_YMM_SE, + XED_NONTERMINAL_YMM_SE32, + XED_NONTERMINAL_YMM_SE64, + XED_NONTERMINAL_ZMM_B3, + XED_NONTERMINAL_ZMM_B3_32, + XED_NONTERMINAL_ZMM_B3_64, + XED_NONTERMINAL_ZMM_I3, + XED_NONTERMINAL_ZMM_N3, + XED_NONTERMINAL_ZMM_N3_32, + XED_NONTERMINAL_ZMM_N3_64, + XED_NONTERMINAL_ZMM_R3, + XED_NONTERMINAL_ZMM_R3_32, + XED_NONTERMINAL_ZMM_R3_64, + XED_NONTERMINAL_LAST +} xed_nonterminal_enum_t; + +/// This converts strings to #xed_nonterminal_enum_t types. +/// @param s A C-string. +/// @return #xed_nonterminal_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_nonterminal_enum_t str2xed_nonterminal_enum_t(const char* s); +/// This converts strings to #xed_nonterminal_enum_t types. +/// @param p An enumeration element of type xed_nonterminal_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_nonterminal_enum_t2str(const xed_nonterminal_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_nonterminal_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_nonterminal_enum_t xed_nonterminal_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-accessors.h b/third_party/xed-intel64/include/xed-operand-accessors.h new file mode 100644 index 0000000..cdfa1a7 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-accessors.h @@ -0,0 +1,1533 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-accessors.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_ACCESSORS_H_) +# define _XED_OPERAND_ACCESSORS_H_ +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-operand-storage.h" +static XED_INLINE xed_bits_t xed3_operand_get_sib(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sib(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_last_f2f3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_last_f2f3(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_uint8_t xed3_operand_get_disp_width(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_disp_width(xed_decoded_inst_t* d, xed_uint8_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_using_default_segment0(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_using_default_segment1(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_hint(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_hint(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_sae(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sae(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mode_first_prefix(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mode_first_prefix(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_uint8_t xed3_operand_get_uimm1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_uimm1(xed_decoded_inst_t* d, xed_uint8_t opval); + +static XED_INLINE xed_uint64_t xed3_operand_get_uimm0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_uimm0(xed_decoded_inst_t* d, xed_uint64_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_smode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_smode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_modrm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_modrm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_chip_enum_t xed3_operand_get_chip(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_chip(xed_decoded_inst_t* d, xed_chip_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_amd3dnow(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_amd3dnow(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_map(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_map(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_sibindex(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sibindex(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_agen(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_agen(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_nominal_opcode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_seg1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_seg1(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_seg0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_seg0(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_nprefixes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_nprefixes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_index(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_index(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_ild_f2(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_ild_f2(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_scale(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_scale(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_llrc(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_llrc(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_sreg(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sreg(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_esrc(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_esrc(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_nrexes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_nrexes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_sib(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_sib(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_osz(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_osz(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_has_sib(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_has_sib(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_eosz(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_eosz(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_element_size(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_element_size(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_disp(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_disp(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_ubit(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_ubit(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vexdest210(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vexdest210(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vexdest3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vexdest3(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_ptr(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_ptr(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_p4(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_p4(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_modep55c(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_modep55c(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_iclass_enum_t xed3_operand_get_iclass(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_iclass(xed_decoded_inst_t* d, xed_iclass_enum_t opval); + +static XED_INLINE xed_uint8_t xed3_operand_get_imm_width(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_imm_width(xed_decoded_inst_t* d, xed_uint8_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_bcrc(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_bcrc(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_error_enum_t xed3_operand_get_error(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_error(xed_decoded_inst_t* d, xed_error_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_evexrr(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_evexrr(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_nelem(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_nelem(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_imm0signed(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_imm0signed(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg8(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg8(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg6(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg6(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg7(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg7(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg4(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg4(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg5(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg5(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg2(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg2(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg3(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg0(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg1(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_base0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_base0(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_base1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_base1(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mod(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mod(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_int64_t xed3_operand_get_disp(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_disp(xed_decoded_inst_t* d, xed_int64_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rex(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rex(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rexb(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rexb(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_imm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_imm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rep(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rep(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rexw(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rexw(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_ild_f3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_ild_f3(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rexr(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rexr(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_encoder_preferred(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_encoder_preferred(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_reg(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_reg(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_nominal_opcode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rexx(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rexx(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_prefix66(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_prefix66(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_rexrr(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_rexrr(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_asz(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_asz(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mask(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mask(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mem1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mem1(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_easz(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_easz(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_imm1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_imm1(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_uint16_t xed3_operand_get_mem_width(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mem_width(xed_decoded_inst_t* d, xed_uint16_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mem0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mem0(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_uint8_t xed3_operand_get_brdisp_width(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_brdisp_width(xed_decoded_inst_t* d, xed_uint8_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_imm1_bytes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_imm1_bytes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_df64(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_df64(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_lock(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_lock(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_has_modrm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_has_modrm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_zeroing(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_zeroing(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_srm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_srm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vexvalid(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vexvalid(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_needrex(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_needrex(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_skip_osz(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_skip_osz(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_reg_enum_t xed3_operand_get_outreg(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_outreg(xed_decoded_inst_t* d, xed_reg_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_default_seg(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_default_seg(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_nseg_prefixes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_nseg_prefixes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vex_c4(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vex_c4(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_pos_modrm(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_pos_modrm(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_bcast(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_bcast(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_operand_element_type_enum_t xed3_operand_get_type(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_type(xed_decoded_inst_t* d, xed_operand_element_type_enum_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_seg_ovd(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_seg_ovd(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vex_prefix(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vex_prefix(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_dummy(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_dummy(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_norex(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_norex(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_roundc(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_roundc(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_sibbase(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sibbase(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_need_memdisp(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_need_memdisp(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_out_of_bytes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_out_of_bytes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_imm1(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_imm1(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_imm0(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_imm0(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_hsw(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_hsw(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_relbr(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_relbr(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_ild_seg(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_ild_seg(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_df32(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_df32(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_realmode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_realmode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_modrm_byte(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_modrm_byte(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_no_scale_disp8(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_no_scale_disp8(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_mpxmode(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_mpxmode(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_sibscale(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_sibscale(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_esrc3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_esrc3(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vl(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vl(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_max_bytes(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_max_bytes(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_modep5(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_modep5(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_first_f2f3(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_first_f2f3(xed_decoded_inst_t* d, xed_bits_t opval); + +static XED_INLINE xed_bits_t xed3_operand_get_vexdest4(const xed_decoded_inst_t* d); + +static XED_INLINE void xed3_operand_set_vexdest4(xed_decoded_inst_t* d, xed_bits_t opval); + +void xed3_get_generic_operand(const xed_decoded_inst_t* d, xed_operand_enum_t operand, void* ret_arg); + +void xed3_set_generic_operand(xed_decoded_inst_t* d, xed_operand_enum_t operand, xed_uint32_t val); + +static XED_INLINE xed_bits_t xed3_operand_get_sib(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sib; +} +static XED_INLINE void xed3_operand_set_sib(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sib = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_last_f2f3(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.last_f2f3; +} +static XED_INLINE void xed3_operand_set_last_f2f3(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.last_f2f3 = (xed_uint8_t)opval; +} +static XED_INLINE xed_uint8_t xed3_operand_get_disp_width(const xed_decoded_inst_t* d) +{ +return (xed_uint8_t)d->_operands.disp_width; +} +static XED_INLINE void xed3_operand_set_disp_width(xed_decoded_inst_t* d, xed_uint8_t opval) +{ +d->_operands.disp_width = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment0(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.using_default_segment0; +} +static XED_INLINE void xed3_operand_set_using_default_segment0(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.using_default_segment0 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment1(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.using_default_segment1; +} +static XED_INLINE void xed3_operand_set_using_default_segment1(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.using_default_segment1 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_hint(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.hint; +} +static XED_INLINE void xed3_operand_set_hint(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.hint = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_sae(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sae; +} +static XED_INLINE void xed3_operand_set_sae(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sae = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mode_first_prefix(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mode_first_prefix; +} +static XED_INLINE void xed3_operand_set_mode_first_prefix(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mode_first_prefix = (xed_uint8_t)opval; +} +static XED_INLINE xed_uint8_t xed3_operand_get_uimm1(const xed_decoded_inst_t* d) +{ +return (xed_uint8_t)d->_operands.uimm1; +} +static XED_INLINE void xed3_operand_set_uimm1(xed_decoded_inst_t* d, xed_uint8_t opval) +{ +d->_operands.uimm1 = (xed_uint8_t)opval; +} +static XED_INLINE xed_uint64_t xed3_operand_get_uimm0(const xed_decoded_inst_t* d) +{ +return (xed_uint64_t)d->_operands.uimm0; +} +static XED_INLINE void xed3_operand_set_uimm0(xed_decoded_inst_t* d, xed_uint64_t opval) +{ +d->_operands.uimm0 = (xed_uint64_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_smode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.smode; +} +static XED_INLINE void xed3_operand_set_smode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.smode = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rm; +} +static XED_INLINE void xed3_operand_set_rm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rm = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_modrm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.modrm; +} +static XED_INLINE void xed3_operand_set_modrm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.modrm = (xed_uint8_t)opval; +} +static XED_INLINE xed_chip_enum_t xed3_operand_get_chip(const xed_decoded_inst_t* d) +{ +return (xed_chip_enum_t)d->_operands.chip; +} +static XED_INLINE void xed3_operand_set_chip(xed_decoded_inst_t* d, xed_chip_enum_t opval) +{ +d->_operands.chip = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_amd3dnow(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.amd3dnow; +} +static XED_INLINE void xed3_operand_set_amd3dnow(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.amd3dnow = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_map(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.map; +} +static XED_INLINE void xed3_operand_set_map(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.map = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_sibindex(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sibindex; +} +static XED_INLINE void xed3_operand_set_sibindex(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sibindex = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_agen(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.agen; +} +static XED_INLINE void xed3_operand_set_agen(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.agen = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_nominal_opcode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.nominal_opcode; +} +static XED_INLINE void xed3_operand_set_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.nominal_opcode = (xed_uint8_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_seg1(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.seg1; +} +static XED_INLINE void xed3_operand_set_seg1(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.seg1 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_seg0(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.seg0; +} +static XED_INLINE void xed3_operand_set_seg0(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.seg0 = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_nprefixes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.nprefixes; +} +static XED_INLINE void xed3_operand_set_nprefixes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.nprefixes = (xed_uint8_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_index(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.index; +} +static XED_INLINE void xed3_operand_set_index(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.index = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_ild_f2(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.ild_f2; +} +static XED_INLINE void xed3_operand_set_ild_f2(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.ild_f2 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_scale(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.scale; +} +static XED_INLINE void xed3_operand_set_scale(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.scale = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_llrc(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.llrc; +} +static XED_INLINE void xed3_operand_set_llrc(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.llrc = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_sreg(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sreg; +} +static XED_INLINE void xed3_operand_set_sreg(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sreg = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_esrc(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.esrc; +} +static XED_INLINE void xed3_operand_set_esrc(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.esrc = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_nrexes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.nrexes; +} +static XED_INLINE void xed3_operand_set_nrexes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.nrexes = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_sib(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_sib; +} +static XED_INLINE void xed3_operand_set_pos_sib(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_sib = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_osz(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.osz; +} +static XED_INLINE void xed3_operand_set_osz(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.osz = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_has_sib(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.has_sib; +} +static XED_INLINE void xed3_operand_set_has_sib(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.has_sib = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_eosz(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.eosz; +} +static XED_INLINE void xed3_operand_set_eosz(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.eosz = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_element_size(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.element_size; +} +static XED_INLINE void xed3_operand_set_element_size(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.element_size = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_disp(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_disp; +} +static XED_INLINE void xed3_operand_set_pos_disp(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_disp = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_ubit(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.ubit; +} +static XED_INLINE void xed3_operand_set_ubit(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.ubit = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vexdest210(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vexdest210; +} +static XED_INLINE void xed3_operand_set_vexdest210(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vexdest210 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vexdest3(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vexdest3; +} +static XED_INLINE void xed3_operand_set_vexdest3(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vexdest3 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_ptr(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.ptr; +} +static XED_INLINE void xed3_operand_set_ptr(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.ptr = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_p4(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.p4; +} +static XED_INLINE void xed3_operand_set_p4(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.p4 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_modep55c(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.modep55c; +} +static XED_INLINE void xed3_operand_set_modep55c(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.modep55c = (xed_uint8_t)opval; +} +static XED_INLINE xed_iclass_enum_t xed3_operand_get_iclass(const xed_decoded_inst_t* d) +{ +return (xed_iclass_enum_t)d->_operands.iclass; +} +static XED_INLINE void xed3_operand_set_iclass(xed_decoded_inst_t* d, xed_iclass_enum_t opval) +{ +d->_operands.iclass = (xed_uint16_t)opval; +} +static XED_INLINE xed_uint8_t xed3_operand_get_imm_width(const xed_decoded_inst_t* d) +{ +return (xed_uint8_t)d->_operands.imm_width; +} +static XED_INLINE void xed3_operand_set_imm_width(xed_decoded_inst_t* d, xed_uint8_t opval) +{ +d->_operands.imm_width = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_bcrc(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.bcrc; +} +static XED_INLINE void xed3_operand_set_bcrc(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.bcrc = (xed_uint8_t)opval; +} +static XED_INLINE xed_error_enum_t xed3_operand_get_error(const xed_decoded_inst_t* d) +{ +return (xed_error_enum_t)d->_operands.error; +} +static XED_INLINE void xed3_operand_set_error(xed_decoded_inst_t* d, xed_error_enum_t opval) +{ +d->_operands.error = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_evexrr(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.evexrr; +} +static XED_INLINE void xed3_operand_set_evexrr(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.evexrr = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_nelem(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.nelem; +} +static XED_INLINE void xed3_operand_set_nelem(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.nelem = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_imm0signed(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.imm0signed; +} +static XED_INLINE void xed3_operand_set_imm0signed(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.imm0signed = (xed_uint8_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg8(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg8; +} +static XED_INLINE void xed3_operand_set_reg8(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg8 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg6(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg6; +} +static XED_INLINE void xed3_operand_set_reg6(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg6 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg7(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg7; +} +static XED_INLINE void xed3_operand_set_reg7(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg7 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg4(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg4; +} +static XED_INLINE void xed3_operand_set_reg4(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg4 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg5(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg5; +} +static XED_INLINE void xed3_operand_set_reg5(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg5 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg2(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg2; +} +static XED_INLINE void xed3_operand_set_reg2(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg2 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg3(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg3; +} +static XED_INLINE void xed3_operand_set_reg3(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg3 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg0(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg0; +} +static XED_INLINE void xed3_operand_set_reg0(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg0 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_reg1(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.reg1; +} +static XED_INLINE void xed3_operand_set_reg1(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.reg1 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_base0(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.base0; +} +static XED_INLINE void xed3_operand_set_base0(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.base0 = (xed_uint16_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_base1(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.base1; +} +static XED_INLINE void xed3_operand_set_base1(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.base1 = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mod(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mod; +} +static XED_INLINE void xed3_operand_set_mod(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mod = (xed_uint8_t)opval; +} +static XED_INLINE xed_int64_t xed3_operand_get_disp(const xed_decoded_inst_t* d) +{ +return (xed_int64_t)d->_operands.disp; +} +static XED_INLINE void xed3_operand_set_disp(xed_decoded_inst_t* d, xed_int64_t opval) +{ +d->_operands.disp = (xed_uint64_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rex(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rex; +} +static XED_INLINE void xed3_operand_set_rex(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rex = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rexb(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rexb; +} +static XED_INLINE void xed3_operand_set_rexb(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rexb = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_imm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_imm; +} +static XED_INLINE void xed3_operand_set_pos_imm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_imm = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rep(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rep; +} +static XED_INLINE void xed3_operand_set_rep(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rep = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rexw(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rexw; +} +static XED_INLINE void xed3_operand_set_rexw(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rexw = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_ild_f3(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.ild_f3; +} +static XED_INLINE void xed3_operand_set_ild_f3(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.ild_f3 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rexr(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rexr; +} +static XED_INLINE void xed3_operand_set_rexr(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rexr = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_encoder_preferred(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.encoder_preferred; +} +static XED_INLINE void xed3_operand_set_encoder_preferred(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.encoder_preferred = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_reg(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.reg; +} +static XED_INLINE void xed3_operand_set_reg(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.reg = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_nominal_opcode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_nominal_opcode; +} +static XED_INLINE void xed3_operand_set_pos_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_nominal_opcode = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rexx(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rexx; +} +static XED_INLINE void xed3_operand_set_rexx(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rexx = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_prefix66(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.prefix66; +} +static XED_INLINE void xed3_operand_set_prefix66(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.prefix66 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_rexrr(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.rexrr; +} +static XED_INLINE void xed3_operand_set_rexrr(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.rexrr = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_asz(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.asz; +} +static XED_INLINE void xed3_operand_set_asz(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.asz = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mask(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mask; +} +static XED_INLINE void xed3_operand_set_mask(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mask = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mem1(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mem1; +} +static XED_INLINE void xed3_operand_set_mem1(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mem1 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_easz(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.easz; +} +static XED_INLINE void xed3_operand_set_easz(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.easz = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_imm1(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_imm1; +} +static XED_INLINE void xed3_operand_set_pos_imm1(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_imm1 = (xed_uint8_t)opval; +} +static XED_INLINE xed_uint16_t xed3_operand_get_mem_width(const xed_decoded_inst_t* d) +{ +return (xed_uint16_t)d->_operands.mem_width; +} +static XED_INLINE void xed3_operand_set_mem_width(xed_decoded_inst_t* d, xed_uint16_t opval) +{ +d->_operands.mem_width = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mem0(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mem0; +} +static XED_INLINE void xed3_operand_set_mem0(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mem0 = (xed_uint8_t)opval; +} +static XED_INLINE xed_uint8_t xed3_operand_get_brdisp_width(const xed_decoded_inst_t* d) +{ +return (xed_uint8_t)d->_operands.brdisp_width; +} +static XED_INLINE void xed3_operand_set_brdisp_width(xed_decoded_inst_t* d, xed_uint8_t opval) +{ +d->_operands.brdisp_width = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_imm1_bytes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.imm1_bytes; +} +static XED_INLINE void xed3_operand_set_imm1_bytes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.imm1_bytes = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_df64(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.df64; +} +static XED_INLINE void xed3_operand_set_df64(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.df64 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_lock(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.lock; +} +static XED_INLINE void xed3_operand_set_lock(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.lock = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_has_modrm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.has_modrm; +} +static XED_INLINE void xed3_operand_set_has_modrm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.has_modrm = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_zeroing(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.zeroing; +} +static XED_INLINE void xed3_operand_set_zeroing(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.zeroing = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_srm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.srm; +} +static XED_INLINE void xed3_operand_set_srm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.srm = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vexvalid(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vexvalid; +} +static XED_INLINE void xed3_operand_set_vexvalid(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vexvalid = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_needrex(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.needrex; +} +static XED_INLINE void xed3_operand_set_needrex(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.needrex = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_skip_osz(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.skip_osz; +} +static XED_INLINE void xed3_operand_set_skip_osz(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.skip_osz = (xed_uint8_t)opval; +} +static XED_INLINE xed_reg_enum_t xed3_operand_get_outreg(const xed_decoded_inst_t* d) +{ +return (xed_reg_enum_t)d->_operands.outreg; +} +static XED_INLINE void xed3_operand_set_outreg(xed_decoded_inst_t* d, xed_reg_enum_t opval) +{ +d->_operands.outreg = (xed_uint16_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_default_seg(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.default_seg; +} +static XED_INLINE void xed3_operand_set_default_seg(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.default_seg = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_nseg_prefixes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.nseg_prefixes; +} +static XED_INLINE void xed3_operand_set_nseg_prefixes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.nseg_prefixes = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vex_c4(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vex_c4; +} +static XED_INLINE void xed3_operand_set_vex_c4(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vex_c4 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_pos_modrm(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.pos_modrm; +} +static XED_INLINE void xed3_operand_set_pos_modrm(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.pos_modrm = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_bcast(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.bcast; +} +static XED_INLINE void xed3_operand_set_bcast(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.bcast = (xed_uint8_t)opval; +} +static XED_INLINE xed_operand_element_type_enum_t xed3_operand_get_type(const xed_decoded_inst_t* d) +{ +return (xed_operand_element_type_enum_t)d->_operands.type; +} +static XED_INLINE void xed3_operand_set_type(xed_decoded_inst_t* d, xed_operand_element_type_enum_t opval) +{ +d->_operands.type = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_seg_ovd(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.seg_ovd; +} +static XED_INLINE void xed3_operand_set_seg_ovd(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.seg_ovd = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vex_prefix(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vex_prefix; +} +static XED_INLINE void xed3_operand_set_vex_prefix(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vex_prefix = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_dummy(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.dummy; +} +static XED_INLINE void xed3_operand_set_dummy(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.dummy = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_norex(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.norex; +} +static XED_INLINE void xed3_operand_set_norex(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.norex = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_roundc(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.roundc; +} +static XED_INLINE void xed3_operand_set_roundc(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.roundc = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_sibbase(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sibbase; +} +static XED_INLINE void xed3_operand_set_sibbase(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sibbase = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_need_memdisp(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.need_memdisp; +} +static XED_INLINE void xed3_operand_set_need_memdisp(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.need_memdisp = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_out_of_bytes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.out_of_bytes; +} +static XED_INLINE void xed3_operand_set_out_of_bytes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.out_of_bytes = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_imm1(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.imm1; +} +static XED_INLINE void xed3_operand_set_imm1(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.imm1 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_imm0(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.imm0; +} +static XED_INLINE void xed3_operand_set_imm0(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.imm0 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_hsw(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.hsw; +} +static XED_INLINE void xed3_operand_set_hsw(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.hsw = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_relbr(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.relbr; +} +static XED_INLINE void xed3_operand_set_relbr(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.relbr = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_ild_seg(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.ild_seg; +} +static XED_INLINE void xed3_operand_set_ild_seg(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.ild_seg = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_df32(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.df32; +} +static XED_INLINE void xed3_operand_set_df32(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.df32 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_realmode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.realmode; +} +static XED_INLINE void xed3_operand_set_realmode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.realmode = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_modrm_byte(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.modrm_byte; +} +static XED_INLINE void xed3_operand_set_modrm_byte(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.modrm_byte = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_no_scale_disp8(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.no_scale_disp8; +} +static XED_INLINE void xed3_operand_set_no_scale_disp8(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.no_scale_disp8 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mode; +} +static XED_INLINE void xed3_operand_set_mode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mode = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_mpxmode(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.mpxmode; +} +static XED_INLINE void xed3_operand_set_mpxmode(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.mpxmode = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_sibscale(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.sibscale; +} +static XED_INLINE void xed3_operand_set_sibscale(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.sibscale = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_esrc3(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.esrc3; +} +static XED_INLINE void xed3_operand_set_esrc3(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.esrc3 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vl(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vl; +} +static XED_INLINE void xed3_operand_set_vl(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vl = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_max_bytes(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.max_bytes; +} +static XED_INLINE void xed3_operand_set_max_bytes(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.max_bytes = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_modep5(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.modep5; +} +static XED_INLINE void xed3_operand_set_modep5(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.modep5 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_first_f2f3(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.first_f2f3; +} +static XED_INLINE void xed3_operand_set_first_f2f3(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.first_f2f3 = (xed_uint8_t)opval; +} +static XED_INLINE xed_bits_t xed3_operand_get_vexdest4(const xed_decoded_inst_t* d) +{ +return (xed_bits_t)d->_operands.vexdest4; +} +static XED_INLINE void xed3_operand_set_vexdest4(xed_decoded_inst_t* d, xed_bits_t opval) +{ +d->_operands.vexdest4 = (xed_uint8_t)opval; +} +#endif diff --git a/third_party/xed-intel64/include/xed-operand-action-enum.h b/third_party/xed-intel64/include/xed-operand-action-enum.h new file mode 100644 index 0000000..0049bc8 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-action-enum.h @@ -0,0 +1,67 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-action-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_ACTION_ENUM_H_) +# define _XED_OPERAND_ACTION_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_ACTION_INVALID, + XED_OPERAND_ACTION_RW, ///< Read and written (must write) + XED_OPERAND_ACTION_R, ///< Read-only + XED_OPERAND_ACTION_W, ///< Write-only (must write) + XED_OPERAND_ACTION_RCW, ///< Read and conditionlly written (may write) + XED_OPERAND_ACTION_CW, ///< Conditionlly written (may write) + XED_OPERAND_ACTION_CRW, ///< Conditionlly read, always written (must write) + XED_OPERAND_ACTION_CR, ///< Conditional read + XED_OPERAND_ACTION_LAST +} xed_operand_action_enum_t; + +/// This converts strings to #xed_operand_action_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_action_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_action_enum_t str2xed_operand_action_enum_t(const char* s); +/// This converts strings to #xed_operand_action_enum_t types. +/// @param p An enumeration element of type xed_operand_action_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_action_enum_t2str(const xed_operand_action_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_action_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_action_enum_t xed_operand_action_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-action.h b/third_party/xed-intel64/include/xed-operand-action.h new file mode 100644 index 0000000..72b0351 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-action.h @@ -0,0 +1,50 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-action.h +/// + +#if !defined(_XED_OPERAND_ACTION_H_) +# define _XED_OPERAND_ACTION_H_ + +#include "../../../third_party/xed-intel64/include/xed-operand-action-enum.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + +XED_DLL_EXPORT xed_uint_t xed_operand_action_read(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_read_only(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_written(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_written_only(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_read_and_written(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_conditional_read(const xed_operand_action_enum_t rw); +XED_DLL_EXPORT xed_uint_t xed_operand_action_conditional_write(const xed_operand_action_enum_t rw); + +#endif + diff --git a/third_party/xed-intel64/include/xed-operand-convert-enum.h b/third_party/xed-intel64/include/xed-operand-convert-enum.h new file mode 100644 index 0000000..fe8f04d --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-convert-enum.h @@ -0,0 +1,64 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-convert-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_CONVERT_ENUM_H_) +# define _XED_OPERAND_CONVERT_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_CONVERT_INVALID, + XED_OPERAND_CONVERT_ZEROSTR, + XED_OPERAND_CONVERT_SAESTR, + XED_OPERAND_CONVERT_ROUNDC, + XED_OPERAND_CONVERT_BCASTSTR, + XED_OPERAND_CONVERT_LAST +} xed_operand_convert_enum_t; + +/// This converts strings to #xed_operand_convert_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_convert_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_convert_enum_t str2xed_operand_convert_enum_t(const char* s); +/// This converts strings to #xed_operand_convert_enum_t types. +/// @param p An enumeration element of type xed_operand_convert_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_convert_enum_t2str(const xed_operand_convert_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_convert_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_convert_enum_t xed_operand_convert_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-ctype-enum.h b/third_party/xed-intel64/include/xed-operand-ctype-enum.h new file mode 100644 index 0000000..7d2e942 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-ctype-enum.h @@ -0,0 +1,70 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-ctype-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_CTYPE_ENUM_H_) +# define _XED_OPERAND_CTYPE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_CTYPE_INVALID, + XED_OPERAND_CTYPE_XED_BITS_T, + XED_OPERAND_CTYPE_XED_CHIP_ENUM_T, + XED_OPERAND_CTYPE_XED_ERROR_ENUM_T, + XED_OPERAND_CTYPE_XED_ICLASS_ENUM_T, + XED_OPERAND_CTYPE_XED_INT64_T, + XED_OPERAND_CTYPE_XED_OPERAND_ELEMENT_TYPE_ENUM_T, + XED_OPERAND_CTYPE_XED_REG_ENUM_T, + XED_OPERAND_CTYPE_XED_UINT16_T, + XED_OPERAND_CTYPE_XED_UINT64_T, + XED_OPERAND_CTYPE_XED_UINT8_T, + XED_OPERAND_CTYPE_LAST +} xed_operand_ctype_enum_t; + +/// This converts strings to #xed_operand_ctype_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_ctype_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_ctype_enum_t str2xed_operand_ctype_enum_t(const char* s); +/// This converts strings to #xed_operand_ctype_enum_t types. +/// @param p An enumeration element of type xed_operand_ctype_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_ctype_enum_t2str(const xed_operand_ctype_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_ctype_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_ctype_enum_t xed_operand_ctype_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-ctype-map.h b/third_party/xed-intel64/include/xed-operand-ctype-map.h new file mode 100644 index 0000000..25d24cd --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-ctype-map.h @@ -0,0 +1,42 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-ctype-map.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_CTYPE_MAP_H_) +# define _XED_OPERAND_CTYPE_MAP_H_ +#include "xed-internal-header.h" +xed_operand_ctype_enum_t xed_operand_get_ctype(xed_operand_enum_t opname); +unsigned int xed_operand_decider_get_width(xed_operand_enum_t opname); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-element-type-enum.h b/third_party/xed-intel64/include/xed-operand-element-type-enum.h new file mode 100644 index 0000000..0fa89a4 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-element-type-enum.h @@ -0,0 +1,69 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-element-type-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_ELEMENT_TYPE_ENUM_H_) +# define _XED_OPERAND_ELEMENT_TYPE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_ELEMENT_TYPE_INVALID, + XED_OPERAND_ELEMENT_TYPE_UINT, ///< Unsigned integer + XED_OPERAND_ELEMENT_TYPE_INT, ///< Signed integer + XED_OPERAND_ELEMENT_TYPE_SINGLE, ///< 32b FP single precision + XED_OPERAND_ELEMENT_TYPE_DOUBLE, ///< 64b FP double precision + XED_OPERAND_ELEMENT_TYPE_LONGDOUBLE, ///< 80b FP x87 + XED_OPERAND_ELEMENT_TYPE_LONGBCD, ///< 80b decimal BCD + XED_OPERAND_ELEMENT_TYPE_STRUCT, ///< a structure of various fields + XED_OPERAND_ELEMENT_TYPE_VARIABLE, ///< depends on other fields in the instruction + XED_OPERAND_ELEMENT_TYPE_FLOAT16, ///< 16b floating point + XED_OPERAND_ELEMENT_TYPE_LAST +} xed_operand_element_type_enum_t; + +/// This converts strings to #xed_operand_element_type_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_element_type_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_element_type_enum_t str2xed_operand_element_type_enum_t(const char* s); +/// This converts strings to #xed_operand_element_type_enum_t types. +/// @param p An enumeration element of type xed_operand_element_type_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_element_type_enum_t2str(const xed_operand_element_type_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_element_type_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_element_type_enum_t xed_operand_element_type_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-element-xtype-enum.h b/third_party/xed-intel64/include/xed-operand-element-xtype-enum.h new file mode 100644 index 0000000..18f8ee2 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-element-xtype-enum.h @@ -0,0 +1,80 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-element-xtype-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_ELEMENT_XTYPE_ENUM_H_) +# define _XED_OPERAND_ELEMENT_XTYPE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_XTYPE_INVALID, + XED_OPERAND_XTYPE_B80, + XED_OPERAND_XTYPE_F16, + XED_OPERAND_XTYPE_F32, + XED_OPERAND_XTYPE_F64, + XED_OPERAND_XTYPE_F80, + XED_OPERAND_XTYPE_I1, + XED_OPERAND_XTYPE_I16, + XED_OPERAND_XTYPE_I32, + XED_OPERAND_XTYPE_I64, + XED_OPERAND_XTYPE_I8, + XED_OPERAND_XTYPE_INT, + XED_OPERAND_XTYPE_STRUCT, + XED_OPERAND_XTYPE_U128, + XED_OPERAND_XTYPE_U16, + XED_OPERAND_XTYPE_U256, + XED_OPERAND_XTYPE_U32, + XED_OPERAND_XTYPE_U64, + XED_OPERAND_XTYPE_U8, + XED_OPERAND_XTYPE_UINT, + XED_OPERAND_XTYPE_VAR, + XED_OPERAND_XTYPE_LAST +} xed_operand_element_xtype_enum_t; + +/// This converts strings to #xed_operand_element_xtype_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_element_xtype_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_element_xtype_enum_t str2xed_operand_element_xtype_enum_t(const char* s); +/// This converts strings to #xed_operand_element_xtype_enum_t types. +/// @param p An enumeration element of type xed_operand_element_xtype_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_element_xtype_enum_t2str(const xed_operand_element_xtype_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_element_xtype_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_element_xtype_enum_t xed_operand_element_xtype_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-enum.h b/third_party/xed-intel64/include/xed-operand-enum.h new file mode 100644 index 0000000..c73e27b --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-enum.h @@ -0,0 +1,184 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_ENUM_H_) +# define _XED_OPERAND_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_INVALID, + XED_OPERAND_AGEN, + XED_OPERAND_AMD3DNOW, + XED_OPERAND_ASZ, + XED_OPERAND_BASE0, + XED_OPERAND_BASE1, + XED_OPERAND_BCAST, + XED_OPERAND_BCRC, + XED_OPERAND_BRDISP_WIDTH, + XED_OPERAND_CHIP, + XED_OPERAND_DEFAULT_SEG, + XED_OPERAND_DF32, + XED_OPERAND_DF64, + XED_OPERAND_DISP_WIDTH, + XED_OPERAND_DISP, + XED_OPERAND_DUMMY, + XED_OPERAND_EASZ, + XED_OPERAND_ELEMENT_SIZE, + XED_OPERAND_ENCODER_PREFERRED, + XED_OPERAND_EOSZ, + XED_OPERAND_ERROR, + XED_OPERAND_ESRC, + XED_OPERAND_ESRC3, + XED_OPERAND_EVEXRR, + XED_OPERAND_FIRST_F2F3, + XED_OPERAND_HAS_SIB, + XED_OPERAND_HAS_MODRM, + XED_OPERAND_HINT, + XED_OPERAND_HSW, + XED_OPERAND_ICLASS, + XED_OPERAND_ILD_F2, + XED_OPERAND_ILD_F3, + XED_OPERAND_ILD_SEG, + XED_OPERAND_IMM_WIDTH, + XED_OPERAND_IMM0SIGNED, + XED_OPERAND_IMM0, + XED_OPERAND_IMM1_BYTES, + XED_OPERAND_IMM1, + XED_OPERAND_INDEX, + XED_OPERAND_LAST_F2F3, + XED_OPERAND_LLRC, + XED_OPERAND_LOCK, + XED_OPERAND_MAP, + XED_OPERAND_MASK, + XED_OPERAND_MAX_BYTES, + XED_OPERAND_MEM_WIDTH, + XED_OPERAND_MEM0, + XED_OPERAND_MEM1, + XED_OPERAND_MOD, + XED_OPERAND_MODE_FIRST_PREFIX, + XED_OPERAND_MODE, + XED_OPERAND_MODEP5, + XED_OPERAND_MODEP55C, + XED_OPERAND_MODRM, + XED_OPERAND_MODRM_BYTE, + XED_OPERAND_MPXMODE, + XED_OPERAND_NEED_MEMDISP, + XED_OPERAND_NEEDREX, + XED_OPERAND_NELEM, + XED_OPERAND_NO_SCALE_DISP8, + XED_OPERAND_NOMINAL_OPCODE, + XED_OPERAND_NOREX, + XED_OPERAND_NPREFIXES, + XED_OPERAND_NREXES, + XED_OPERAND_NSEG_PREFIXES, + XED_OPERAND_OSZ, + XED_OPERAND_OUT_OF_BYTES, + XED_OPERAND_OUTREG, + XED_OPERAND_P4, + XED_OPERAND_POS_SIB, + XED_OPERAND_POS_DISP, + XED_OPERAND_POS_IMM, + XED_OPERAND_POS_NOMINAL_OPCODE, + XED_OPERAND_POS_IMM1, + XED_OPERAND_POS_MODRM, + XED_OPERAND_PREFIX66, + XED_OPERAND_PTR, + XED_OPERAND_REALMODE, + XED_OPERAND_REG, + XED_OPERAND_REG0, + XED_OPERAND_REG1, + XED_OPERAND_REG2, + XED_OPERAND_REG3, + XED_OPERAND_REG4, + XED_OPERAND_REG5, + XED_OPERAND_REG6, + XED_OPERAND_REG7, + XED_OPERAND_REG8, + XED_OPERAND_RELBR, + XED_OPERAND_REP, + XED_OPERAND_REX, + XED_OPERAND_REXB, + XED_OPERAND_REXR, + XED_OPERAND_REXRR, + XED_OPERAND_REXW, + XED_OPERAND_REXX, + XED_OPERAND_RM, + XED_OPERAND_ROUNDC, + XED_OPERAND_SAE, + XED_OPERAND_SCALE, + XED_OPERAND_SEG_OVD, + XED_OPERAND_SEG0, + XED_OPERAND_SEG1, + XED_OPERAND_SIB, + XED_OPERAND_SIBBASE, + XED_OPERAND_SIBINDEX, + XED_OPERAND_SIBSCALE, + XED_OPERAND_SKIP_OSZ, + XED_OPERAND_SMODE, + XED_OPERAND_SREG, + XED_OPERAND_SRM, + XED_OPERAND_TYPE, + XED_OPERAND_UBIT, + XED_OPERAND_UIMM0, + XED_OPERAND_UIMM1, + XED_OPERAND_USING_DEFAULT_SEGMENT0, + XED_OPERAND_USING_DEFAULT_SEGMENT1, + XED_OPERAND_VEX_C4, + XED_OPERAND_VEX_PREFIX, + XED_OPERAND_VEXDEST3, + XED_OPERAND_VEXDEST4, + XED_OPERAND_VEXDEST210, + XED_OPERAND_VEXVALID, + XED_OPERAND_VL, + XED_OPERAND_ZEROING, + XED_OPERAND_LAST +} xed_operand_enum_t; + +/// This converts strings to #xed_operand_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_enum_t str2xed_operand_enum_t(const char* s); +/// This converts strings to #xed_operand_enum_t types. +/// @param p An enumeration element of type xed_operand_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_enum_t2str(const xed_operand_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_enum_t xed_operand_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-storage.h b/third_party/xed-intel64/include/xed-operand-storage.h new file mode 100644 index 0000000..0f300d0 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-storage.h @@ -0,0 +1,170 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-storage.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_STORAGE_H_) +# define _XED_OPERAND_STORAGE_H_ +#include "../../../third_party/xed-intel64/include/xed-chip-enum.h" +#include "../../../third_party/xed-intel64/include/xed-error-enum.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" +#include "../../../third_party/xed-intel64/include/xed-operand-element-type-enum.h" +#include "../../../third_party/xed-intel64/include/xed-reg-enum.h" +typedef struct xed_operand_storage_s { + xed_uint64_t disp; + xed_uint64_t uimm0; + xed_uint16_t mem_width; + xed_uint16_t iclass; + xed_uint16_t base0; + xed_uint16_t base1; + xed_uint16_t element_size; + xed_uint16_t index; + xed_uint16_t outreg; + xed_uint16_t reg0; + xed_uint16_t reg1; + xed_uint16_t reg2; + xed_uint16_t reg3; + xed_uint16_t reg4; + xed_uint16_t reg5; + xed_uint16_t reg6; + xed_uint16_t reg7; + xed_uint16_t reg8; + xed_uint16_t seg0; + xed_uint16_t seg1; + xed_uint8_t brdisp_width; + xed_uint8_t disp_width; + xed_uint8_t ild_seg; + xed_uint8_t imm1_bytes; + xed_uint8_t imm_width; + xed_uint8_t max_bytes; + xed_uint8_t modrm_byte; + xed_uint8_t nominal_opcode; + xed_uint8_t nprefixes; + xed_uint8_t nrexes; + xed_uint8_t nseg_prefixes; + xed_uint8_t pos_disp; + xed_uint8_t pos_imm; + xed_uint8_t pos_imm1; + xed_uint8_t pos_modrm; + xed_uint8_t pos_nominal_opcode; + xed_uint8_t pos_sib; + xed_uint8_t uimm1; + xed_uint8_t chip; + xed_uint8_t need_memdisp; + xed_uint8_t bcast; + xed_uint8_t error; + xed_uint8_t esrc; + xed_uint8_t map; + xed_uint8_t nelem; + xed_uint8_t scale; + xed_uint8_t type; + xed_uint8_t hint; + xed_uint8_t mask; + xed_uint8_t reg; + xed_uint8_t rm; + xed_uint8_t roundc; + xed_uint8_t seg_ovd; + xed_uint8_t sibbase; + xed_uint8_t sibindex; + xed_uint8_t sreg; + xed_uint8_t srm; + xed_uint8_t vexdest210; + xed_uint8_t vexvalid; + xed_uint8_t default_seg; + xed_uint8_t easz; + xed_uint8_t eosz; + xed_uint8_t first_f2f3; + xed_uint8_t has_modrm; + xed_uint8_t last_f2f3; + xed_uint8_t llrc; + xed_uint8_t mod; + xed_uint8_t mode; + xed_uint8_t rep; + xed_uint8_t sibscale; + xed_uint8_t smode; + xed_uint8_t vex_prefix; + xed_uint8_t vl; + xed_uint8_t agen; + xed_uint8_t amd3dnow; + xed_uint8_t asz; + xed_uint8_t bcrc; + xed_uint8_t df32; + xed_uint8_t df64; + xed_uint8_t dummy; + xed_uint8_t encoder_preferred; + xed_uint8_t esrc3; + xed_uint8_t evexrr; + xed_uint8_t has_sib; + xed_uint8_t hsw; + xed_uint8_t ild_f2; + xed_uint8_t ild_f3; + xed_uint8_t imm0; + xed_uint8_t imm0signed; + xed_uint8_t imm1; + xed_uint8_t lock; + xed_uint8_t mem0; + xed_uint8_t mem1; + xed_uint8_t modep5; + xed_uint8_t modep55c; + xed_uint8_t mode_first_prefix; + xed_uint8_t modrm; + xed_uint8_t mpxmode; + xed_uint8_t needrex; + xed_uint8_t norex; + xed_uint8_t no_scale_disp8; + xed_uint8_t osz; + xed_uint8_t out_of_bytes; + xed_uint8_t p4; + xed_uint8_t prefix66; + xed_uint8_t ptr; + xed_uint8_t realmode; + xed_uint8_t relbr; + xed_uint8_t rex; + xed_uint8_t rexb; + xed_uint8_t rexr; + xed_uint8_t rexrr; + xed_uint8_t rexw; + xed_uint8_t rexx; + xed_uint8_t sae; + xed_uint8_t sib; + xed_uint8_t skip_osz; + xed_uint8_t ubit; + xed_uint8_t using_default_segment0; + xed_uint8_t using_default_segment1; + xed_uint8_t vexdest3; + xed_uint8_t vexdest4; + xed_uint8_t vex_c4; + xed_uint8_t zeroing; +} xed_operand_storage_t; +#endif diff --git a/third_party/xed-intel64/include/xed-operand-type-enum.h b/third_party/xed-intel64/include/xed-operand-type-enum.h new file mode 100644 index 0000000..344f7d0 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-type-enum.h @@ -0,0 +1,65 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-type-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_TYPE_ENUM_H_) +# define _XED_OPERAND_TYPE_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_TYPE_INVALID, + XED_OPERAND_TYPE_ERROR, + XED_OPERAND_TYPE_IMM, + XED_OPERAND_TYPE_IMM_CONST, + XED_OPERAND_TYPE_NT_LOOKUP_FN, + XED_OPERAND_TYPE_REG, + XED_OPERAND_TYPE_LAST +} xed_operand_type_enum_t; + +/// This converts strings to #xed_operand_type_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_type_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_type_enum_t str2xed_operand_type_enum_t(const char* s); +/// This converts strings to #xed_operand_type_enum_t types. +/// @param p An enumeration element of type xed_operand_type_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_type_enum_t2str(const xed_operand_type_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_type_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_type_enum_t xed_operand_type_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-values-interface.h b/third_party/xed-intel64/include/xed-operand-values-interface.h new file mode 100644 index 0000000..149b90c --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-values-interface.h @@ -0,0 +1,533 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-values-interface.h +/// + +#if !defined(_XED_OPERAND_VALUES_INTERFACE_H_) +# define _XED_OPERAND_VALUES_INTERFACE_H_ + +#include "../../../third_party/xed-intel64/include/xed-common-defs.h" +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-iclass-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-operand-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-reg-enum.h" // generated +#include "../../../third_party/xed-intel64/include/xed-state.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-types.h" +#include "../../../third_party/xed-intel64/include/xed-util.h" +/// @name Initialization +//@{ +/// @ingroup OPERANDS +/// Initializes operand structure +XED_DLL_EXPORT void xed_operand_values_init(xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Initializes the operand storage and sets mode values. +XED_DLL_EXPORT void xed_operand_values_init_set_mode(xed_operand_values_t* p, + const xed_state_t* dstate); + +/// @ingroup OPERANDS +/// Set the mode values +XED_DLL_EXPORT void +xed_operand_values_set_mode(xed_operand_values_t* p, + const xed_state_t* dstate); + +/// @ingroup OPERANDS +/// Initializes dst operand structure but preserves the existing +/// MODE/SMODE values from the src operand structure. +XED_DLL_EXPORT void +xed_operand_values_init_keep_mode( xed_operand_values_t* dst, + const xed_operand_values_t* src ); +//@} + +/////////////////////////////////////////////////////////// +/// @name String output +//@{ +/// @ingroup OPERANDS +/// Dump all the information about the operands to buf. +XED_DLL_EXPORT void +xed_operand_values_dump(const xed_operand_values_t* ov, + char* buf, + int buflen); +/// @ingroup OPERANDS +/// More tersely dump all the information about the operands to buf. +XED_DLL_EXPORT void +xed_operand_values_print_short(const xed_operand_values_t* ov, + char* buf, + int buflen); +//@} + +/// @name REP/REPNE Prefixes +//@{ +/// @ingroup OPERANDS +/// True if the instruction has a real REP prefix. This returns false if +/// there is no F2/F3 prefix or the F2/F3 prefix is used to refine the +/// opcode as in some SSE operations. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_real_rep(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if the instruction as a F3 REP prefix (used for opcode refining, +/// for rep for string operations, or ignored). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_rep_prefix(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if the instruction as a F2 REP prefix (used for opcode refining, +/// for rep for string operations, or ignored). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_repne_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// for REPNE(F2) prefix on string ops +XED_DLL_EXPORT void xed_operand_values_set_repne(xed_operand_values_t* p); +/// @ingroup OPERANDS +/// for REP(F3) prefix on string ops +XED_DLL_EXPORT void xed_operand_values_set_rep(xed_operand_values_t* p); +/// @ingroup OPERANDS +/// clear the REP prefix indicator +XED_DLL_EXPORT void xed_operand_values_clear_rep(xed_operand_values_t* p); + +//@} + +/// @name Atomic / Locked operations +//@{ +/// @ingroup OPERANDS +/// Returns true if the memory operation has atomic read-modify-write +/// semantics. An XCHG accessing memory is atomic with or without a +/// LOCK prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_atomic(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the memory operation has a valid lock prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_lock_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the instruction could be re-encoded to have a lock +/// prefix but does not have one currently. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_lockable(const xed_operand_values_t* p); +//@} + + +/// @ingroup OPERANDS +/// Indicates if the default segment is being used. +/// @param[in] p the pointer to the #xed_operand_values_t structure. +/// @param[in] i 0 or 1, indicating which memory operation. +/// @return true if the memory operation is using the default segment for +/// the associated addressing mode base register. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_using_default_segment(const xed_operand_values_t* p, + unsigned int i); + + + +/// @ingroup OPERANDS +/// Returns The effective operand width in bits: 16/32/64. Note this is not +/// the same as the width of the operand which can vary! For 8 bit +/// operations, the effective operand width is the machine mode's default +/// width. If you also want to identify byte operations use the higher +/// level function #xed_decoded_inst_get_operand_width() . +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_effective_operand_width(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Returns The effective address width in bits: 16/32/64. +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_effective_address_width(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Returns The stack address width in bits: 16/32/64. +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_stack_address_width(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// True if there is a memory displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_memory_displacement(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if there is a branch displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_branch_displacement(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if there is a memory or branch displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_displacement(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// Deprecated. Compatibility function for XED0. See has_memory_displacement(). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_displacement_for_memop(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return true if there is an immediate operand +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_immediate(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// ALIAS for has_displacement(). +/// Deprecated. See has_memory_displacement() and +/// has_branch_displacement(). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_disp(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// This indicates the presence of a 67 prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_address_size_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// This does not include the cases when the 66 prefix is used an +/// opcode-refining prefix for multibyte opcodes. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_operand_size_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// This includes any 66 prefix that shows up even if it is ignored. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_66_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// This instruction has a REX prefix with the W bit set. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_rexw_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_segment_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return the segment prefix, if any, as a #xed_reg_enum_t value. +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_segment_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_is_prefetch(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_long_mode(const xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_real_mode(const xed_operand_values_t* p); + +/// @name Memory Addressing +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_accesses_memory(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_number_of_memory_operands(const xed_operand_values_t* p); + +/// return bytes +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_get_memory_operand_length(const xed_operand_values_t* p, + unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_base_reg(const xed_operand_values_t* p, + unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_index_reg(const xed_operand_values_t* p, + unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_seg_reg(const xed_operand_values_t* p, + unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_get_scale(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the instruction access memory but without using a MODRM +/// byte limiting its addressing modes. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_memop_without_modrm(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Returns true if the instruction has a MODRM byte. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_modrm_byte(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the instruction has a SIB byte. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_sib_byte(const xed_operand_values_t* p); +//@} + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_branch_not_taken_hint(const xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_branch_taken_hint(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_is_nop(const xed_operand_values_t* p); + + +/// @name Immediates +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_int64_t +xed_operand_values_get_immediate_int64(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint64_t +xed_operand_values_get_immediate_uint64(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return true if the first immediate (IMM0) is signed +XED_DLL_EXPORT xed_uint_t +xed_operand_values_get_immediate_is_signed(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// Return the i'th byte of the immediate +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_immediate_byte(const xed_operand_values_t* p, + unsigned int i); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_second_immediate(const xed_operand_values_t* p); +//@} + +/// @name Memory Displacements +//@{ +/// @ingroup OPERANDS +/// Return the memory displacement width in BYTES +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_memory_displacement_length(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Return the memory displacement width in BITS +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_memory_displacement_length_bits( + const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return the raw memory displacement width in BITS(ignores scaling) +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_memory_displacement_length_bits_raw( + const xed_operand_values_t* p); + +/// Returns the potentially scaled value of the memory +/// displacement. Certain AVX512 memory displacements are scaled before +/// they are used. @ingroup OPERANDS +XED_DLL_EXPORT xed_int64_t +xed_operand_values_get_memory_displacement_int64(const xed_operand_values_t* p); + +/// Returns the unscaled (raw) memory displacement. Certain AVX512 memory +/// displacements are scaled before they are used. @ingroup OPERANDS +XED_DLL_EXPORT xed_int64_t +xed_operand_values_get_memory_displacement_int64_raw(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_memory_displacement_byte(const xed_operand_values_t* p, + unsigned int i); +//@} + +/// @name Branch Displacements +//@{ +/// @ingroup OPERANDS +/// Return the branch displacement width in bytes +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_branch_displacement_length(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Return the branch displacement width in bits +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_branch_displacement_length_bits( + const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_int32_t +xed_operand_values_get_branch_displacement_int32(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_branch_displacement_byte(const xed_operand_values_t* p, + unsigned int i); +//@} + + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_iclass_enum_t +xed_operand_values_get_iclass(const xed_operand_values_t* p); + +//////////////////////////////////////////////////// +// ENCODE API +//////////////////////////////////////////////////// +/// @name Encoding +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_zero_immediate(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_zero_branch_displacement(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_zero_memory_displacement(xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_lock(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_zero_segment_override(xed_operand_values_t* p); + + +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_set_iclass(xed_operand_values_t* p, + xed_iclass_enum_t iclass); + +/// @ingroup OPERANDS +/// width is bits 8, 16, 32, 64 +XED_DLL_EXPORT void +xed_operand_values_set_effective_operand_width(xed_operand_values_t* p, + unsigned int width); + +/// @ingroup OPERANDS +/// width is bits 16, 32, 64 +XED_DLL_EXPORT void +xed_operand_values_set_effective_address_width(xed_operand_values_t* p, + unsigned int width); +/// takes bytes, not bits, as an argument +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_set_memory_operand_length(xed_operand_values_t* p, + unsigned int memop_length); + + +/// @ingroup OPERANDS +/// Set the memory displacement using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_memory_displacement(xed_operand_values_t* p, + xed_int64_t x, unsigned int len); +/// @ingroup OPERANDS +/// Set the memory displacement using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_memory_displacement_bits(xed_operand_values_t* p, + xed_int64_t x, + unsigned int len_bits); + +/// @ingroup OPERANDS +/// Indicate that we have a relative branch. +XED_DLL_EXPORT void xed_operand_values_set_relbr(xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Set the branch displacement using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_branch_displacement(xed_operand_values_t* p, + xed_int32_t x, + unsigned int len); +/// @ingroup OPERANDS +/// Set the branch displacement using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_branch_displacement_bits(xed_operand_values_t* p, + xed_int32_t x, + unsigned int len_bits); + +/// @ingroup OPERANDS +/// Set the signed immediate using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_immediate_signed(xed_operand_values_t* p, + xed_int32_t x, + unsigned int bytes); +/// @ingroup OPERANDS +/// Set the signed immediate using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_immediate_signed_bits(xed_operand_values_t* p, + xed_int32_t x, + unsigned int bits); + + +/// @ingroup OPERANDS +/// Set the unsigned immediate using a BYTE length. +XED_DLL_EXPORT void +xed_operand_values_set_immediate_unsigned(xed_operand_values_t* p, + xed_uint64_t x, + unsigned int bytes); +/// @ingroup OPERANDS +/// Set the unsigned immediate using a BIT length. +XED_DLL_EXPORT void +xed_operand_values_set_immediate_unsigned_bits(xed_operand_values_t* p, + xed_uint64_t x, + unsigned int bits); + + + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_base_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_base); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_seg_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_seg); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_index_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_index); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_scale(xed_operand_values_t* p, + xed_uint_t memop_idx, + xed_uint_t new_scale); + + +/// @ingroup OPERANDS +/// Set the operand storage field entry named 'operand_name' to the +/// register value specified by 'reg_name'. +XED_DLL_EXPORT void +xed_operand_values_set_operand_reg(xed_operand_values_t* p, + xed_operand_enum_t operand_name, + xed_reg_enum_t reg_name); + +//@} +#endif + diff --git a/third_party/xed-intel64/include/xed-operand-visibility-enum.h b/third_party/xed-intel64/include/xed-operand-visibility-enum.h new file mode 100644 index 0000000..1518b61 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-visibility-enum.h @@ -0,0 +1,63 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-visibility-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_VISIBILITY_ENUM_H_) +# define _XED_OPERAND_VISIBILITY_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPVIS_INVALID, + XED_OPVIS_EXPLICIT, ///< Shows up in operand encoding + XED_OPVIS_IMPLICIT, ///< Part of the opcode, but listed as an operand + XED_OPVIS_SUPPRESSED, ///< Part of the opcode, but not typically listed as an operand + XED_OPVIS_LAST +} xed_operand_visibility_enum_t; + +/// This converts strings to #xed_operand_visibility_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_visibility_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_visibility_enum_t str2xed_operand_visibility_enum_t(const char* s); +/// This converts strings to #xed_operand_visibility_enum_t types. +/// @param p An enumeration element of type xed_operand_visibility_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_visibility_enum_t2str(const xed_operand_visibility_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_visibility_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_visibility_enum_t xed_operand_visibility_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-operand-width-enum.h b/third_party/xed-intel64/include/xed-operand-width-enum.h new file mode 100644 index 0000000..cdb2ce2 --- /dev/null +++ b/third_party/xed-intel64/include/xed-operand-width-enum.h @@ -0,0 +1,164 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-width-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_OPERAND_WIDTH_ENUM_H_) +# define _XED_OPERAND_WIDTH_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_OPERAND_WIDTH_INVALID, + XED_OPERAND_WIDTH_ASZ, + XED_OPERAND_WIDTH_SSZ, + XED_OPERAND_WIDTH_PSEUDO, + XED_OPERAND_WIDTH_PSEUDOX87, + XED_OPERAND_WIDTH_A16, + XED_OPERAND_WIDTH_A32, + XED_OPERAND_WIDTH_B, + XED_OPERAND_WIDTH_D, + XED_OPERAND_WIDTH_DQ, + XED_OPERAND_WIDTH_XUB, + XED_OPERAND_WIDTH_XUW, + XED_OPERAND_WIDTH_XUD, + XED_OPERAND_WIDTH_XUQ, + XED_OPERAND_WIDTH_X128, + XED_OPERAND_WIDTH_XB, + XED_OPERAND_WIDTH_XW, + XED_OPERAND_WIDTH_XD, + XED_OPERAND_WIDTH_XQ, + XED_OPERAND_WIDTH_MB, + XED_OPERAND_WIDTH_MW, + XED_OPERAND_WIDTH_MD, + XED_OPERAND_WIDTH_MQ, + XED_OPERAND_WIDTH_M64INT, + XED_OPERAND_WIDTH_M64REAL, + XED_OPERAND_WIDTH_MEM108, + XED_OPERAND_WIDTH_MEM14, + XED_OPERAND_WIDTH_MEM16, + XED_OPERAND_WIDTH_MEM16INT, + XED_OPERAND_WIDTH_MEM28, + XED_OPERAND_WIDTH_MEM32INT, + XED_OPERAND_WIDTH_MEM32REAL, + XED_OPERAND_WIDTH_MEM80DEC, + XED_OPERAND_WIDTH_MEM80REAL, + XED_OPERAND_WIDTH_F80, + XED_OPERAND_WIDTH_MEM94, + XED_OPERAND_WIDTH_MFPXENV, + XED_OPERAND_WIDTH_MXSAVE, + XED_OPERAND_WIDTH_MPREFETCH, + XED_OPERAND_WIDTH_P, + XED_OPERAND_WIDTH_P2, + XED_OPERAND_WIDTH_PD, + XED_OPERAND_WIDTH_PS, + XED_OPERAND_WIDTH_PI, + XED_OPERAND_WIDTH_Q, + XED_OPERAND_WIDTH_S, + XED_OPERAND_WIDTH_S64, + XED_OPERAND_WIDTH_SD, + XED_OPERAND_WIDTH_SI, + XED_OPERAND_WIDTH_SS, + XED_OPERAND_WIDTH_V, + XED_OPERAND_WIDTH_Y, + XED_OPERAND_WIDTH_W, + XED_OPERAND_WIDTH_Z, + XED_OPERAND_WIDTH_SPW8, + XED_OPERAND_WIDTH_SPW, + XED_OPERAND_WIDTH_SPW3, + XED_OPERAND_WIDTH_SPW2, + XED_OPERAND_WIDTH_I1, + XED_OPERAND_WIDTH_I2, + XED_OPERAND_WIDTH_I3, + XED_OPERAND_WIDTH_I4, + XED_OPERAND_WIDTH_I5, + XED_OPERAND_WIDTH_I6, + XED_OPERAND_WIDTH_I7, + XED_OPERAND_WIDTH_I8, + XED_OPERAND_WIDTH_VAR, + XED_OPERAND_WIDTH_BND32, + XED_OPERAND_WIDTH_BND64, + XED_OPERAND_WIDTH_QQ, + XED_OPERAND_WIDTH_YUB, + XED_OPERAND_WIDTH_YUW, + XED_OPERAND_WIDTH_YUD, + XED_OPERAND_WIDTH_YUQ, + XED_OPERAND_WIDTH_Y128, + XED_OPERAND_WIDTH_YB, + XED_OPERAND_WIDTH_YW, + XED_OPERAND_WIDTH_YD, + XED_OPERAND_WIDTH_YQ, + XED_OPERAND_WIDTH_YPS, + XED_OPERAND_WIDTH_YPD, + XED_OPERAND_WIDTH_VV, + XED_OPERAND_WIDTH_ZV, + XED_OPERAND_WIDTH_WRD, + XED_OPERAND_WIDTH_MSKW, + XED_OPERAND_WIDTH_ZMSKW, + XED_OPERAND_WIDTH_ZF32, + XED_OPERAND_WIDTH_ZF64, + XED_OPERAND_WIDTH_ZB, + XED_OPERAND_WIDTH_ZW, + XED_OPERAND_WIDTH_ZD, + XED_OPERAND_WIDTH_ZQ, + XED_OPERAND_WIDTH_ZUB, + XED_OPERAND_WIDTH_ZUW, + XED_OPERAND_WIDTH_ZUD, + XED_OPERAND_WIDTH_ZUQ, + XED_OPERAND_WIDTH_ZI8, + XED_OPERAND_WIDTH_ZI16, + XED_OPERAND_WIDTH_ZI32, + XED_OPERAND_WIDTH_ZI64, + XED_OPERAND_WIDTH_ZU8, + XED_OPERAND_WIDTH_ZU16, + XED_OPERAND_WIDTH_ZU32, + XED_OPERAND_WIDTH_ZU64, + XED_OPERAND_WIDTH_ZU128, + XED_OPERAND_WIDTH_LAST +} xed_operand_width_enum_t; + +/// This converts strings to #xed_operand_width_enum_t types. +/// @param s A C-string. +/// @return #xed_operand_width_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_width_enum_t str2xed_operand_width_enum_t(const char* s); +/// This converts strings to #xed_operand_width_enum_t types. +/// @param p An enumeration element of type xed_operand_width_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_operand_width_enum_t2str(const xed_operand_width_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_operand_width_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_operand_width_enum_t xed_operand_width_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-portability.h b/third_party/xed-intel64/include/xed-portability.h new file mode 100644 index 0000000..b94df8b --- /dev/null +++ b/third_party/xed-intel64/include/xed-portability.h @@ -0,0 +1,196 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-portability.h +/// + +#ifndef _XED_PORTABILITY_H_ +# define _XED_PORTABILITY_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +#define XED_STATIC_CAST(x,y) ((x) (y)) +#define XED_REINTERPRET_CAST(x,y) ((x) (y)) +#define XED_CAST(x,y) ((x) (y)) + + + +XED_DLL_EXPORT xed_uint_t xed_strlen(const char* s); +XED_DLL_EXPORT void xed_strcat(char* dst, const char* src); +XED_DLL_EXPORT void xed_strcpy(char* dst, const char* src); + +/// returns the number of bytes remaining for the next use of +/// #xed_strncpy() or #xed_strncat() . +XED_DLL_EXPORT int xed_strncpy(char* dst, const char* src, int len); + +/// returns the number of bytes remaining for the next use of +/// #xed_strncpy() or #xed_strncat() . +XED_DLL_EXPORT int xed_strncat(char* dst, const char* src, int len); + +#if defined(__INTEL_COMPILER) +# if defined(_WIN32) && defined(_MSC_VER) +# if _MSC_VER >= 1400 +# define XED_MSVC8_OR_LATER 1 +# endif +# endif +#endif + +/* recognize VC98 */ +#if !defined(__INTEL_COMPILER) +# if defined(_WIN32) && defined(_MSC_VER) +# if _MSC_VER == 1200 +# define XED_MSVC6 1 +# endif +# endif +# if defined(_WIN32) && defined(_MSC_VER) +# if _MSC_VER == 1310 +# define XED_MSVC7 1 +# endif +# endif +# if defined(_WIN32) && defined(_MSC_VER) +# if _MSC_VER >= 1400 +# define XED_MSVC8_OR_LATER 1 +# endif +# if _MSC_VER == 1400 +# define XED_MSVC8 1 +# endif +# if _MSC_VER == 1500 +# define XED_MSVC9 1 +# endif +# if _MSC_VER >= 1500 +# define XED_MSVC9_OR_LATER 1 +# endif +# if _MSC_VER == 1600 +# define XED_MSVC10 1 +# endif +# if _MSC_VER >= 1600 +# define XED_MSVC10_OR_LATER 1 +# endif +# endif +#endif + +/* I've had compatibilty problems here so I'm using a trivial indirection */ +#if defined(__GNUC__) +# if defined(__CYGWIN__) + /* cygwin's gcc 3.4.4 on windows complains */ +# define XED_FMT_X "%lx" +# define XED_FMT_08X "%08lx" +# define XED_FMT_D "%ld" +# define XED_FMT_U "%lu" +# define XED_FMT_9U "%9lu" +# else +# define XED_FMT_X "%x" +# define XED_FMT_08X "%08x" +# define XED_FMT_D "%d" +# define XED_FMT_U "%u" +# define XED_FMT_9U "%9u" +# endif +#else +# define XED_FMT_X "%x" +# define XED_FMT_08X "%08x" +# define XED_FMT_D "%d" +# define XED_FMT_U "%u" +# define XED_FMT_9U "%9u" +#endif + +// Go write portable code... Sigh +#if defined(__APPLE__) // clang *32b* and 64b +# define XED_FMT_SIZET "%lu" +#elif defined(__LP64__) // 64b gcc, icc +# define XED_FMT_SIZET "%lu" +#elif defined (_M_X64) // 64b msvs, ICL + // MSVS/x64 accepts %llu or %lu, icl/x64 does not) +# define XED_FMT_SIZET "%llu" +#else // 32b everything else +# define XED_FMT_SIZET "%u" +#endif + +#if defined(__GNUC__) && defined(__LP64__) && !defined(__APPLE__) +# define XED_FMT_LX "%lx" +# define XED_FMT_LU "%lu" +# define XED_FMT_LU12 "%12lu" +# define XED_FMT_LD "%ld" +# define XED_FMT_LX16 "%016lx" +#else +# define XED_FMT_LX "%llx" +# define XED_FMT_LU "%llu" +# define XED_FMT_LU12 "%12llu" +# define XED_FMT_LD "%lld" +# define XED_FMT_LX16 "%016llx" +#endif + +#if defined(__LP64__) || defined (_M_X64) +# define XED_64B 1 +#endif + +#if defined(_M_IA64) +# define XED_IPF +# define XED_FMT_SIZET "%lu" +#endif + +#if defined(__GNUC__) + /* gcc4.2.x has a bug with c99/gnu99 inlining */ +# if __GNUC__ == 4 && __GNUC_MINOR__ == 2 +# define XED_INLINE inline +# else +# if __GNUC__ == 2 +# define XED_INLINE +# else +# define XED_INLINE inline +# endif +# endif +# define XED_NORETURN __attribute__ ((noreturn)) +# if __GNUC__ == 2 +# define XED_NOINLINE +# else +# define XED_NOINLINE __attribute__ ((noinline)) +# endif +#else +# define XED_INLINE __inline +# if defined(XED_MSVC6) +# define XED_NOINLINE +# else +# define XED_NOINLINE __declspec(noinline) +# endif +# define XED_NORETURN __declspec(noreturn) +#endif + + + +#define XED_MAX(a, b) (((a) > (b)) ? (a):(b)) +#define XED_MIN(a, b) (((a) < (b)) ? (a):(b)) + + + + +#endif // _XED_PORTABILITY_H_ + diff --git a/third_party/xed-intel64/include/xed-print-info.h b/third_party/xed-intel64/include/xed-print-info.h new file mode 100644 index 0000000..7eb5b30 --- /dev/null +++ b/third_party/xed-intel64/include/xed-print-info.h @@ -0,0 +1,109 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#if !defined(_XED_PRINT_INFO_H_) +# define _XED_PRINT_INFO_H_ + +#include "../../../third_party/xed-intel64/include/xed-decoded-inst.h" +#include "../../../third_party/xed-intel64/include/xed-disas.h" // callback function type +#include "../../../third_party/xed-intel64/include/xed-format-options.h" +#include "../../../third_party/xed-intel64/include/xed-syntax-enum.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + +/// @ingroup PRINT +/// This contains the information used by the various disassembly printers. +/// Call xed_init_print_info to initialize the fields. Then change the +/// required and optional fields when required. +typedef struct { + + ///////////////////////////////////////// + // REQUIRED FIELDS - users should set these + ///////////////////////////////////////// + + /// the decoded instruction to print + const xed_decoded_inst_t* p; + + /// pointer to the output buffer + char* buf; + + /// length of the output buffer. (bytes) Must be > 25 to start. + int blen; + + ///////////////////////////////////////// + // OPTIONAL FIELDS - user can set these + ///////////////////////////////////////// + + /// program counter location. Must be zero if not used. (Sometimes + /// instructions are disassembled in a temporary buffer at a different + /// location than where they may or will exist in memory). + xed_uint64_t runtime_address; + + /// disassembly_callback MUST be set to zero if not used! If zero, the + /// default disassembly callback is used (if one has been registered). + xed_disassembly_callback_fn_t disassembly_callback; + + /// passed to disassembly callback. Can be zero if not used. + void* context; + + /// default is Intel-syntax (dest on left) + xed_syntax_enum_t syntax; + + /// 1=indicated the format_options field is valid, 0=use default + /// formating options from xed_format_set_options(). + int format_options_valid; + xed_format_options_t format_options; + + + ///////////////////////////////////////// + // NONPUBLIC FIELDS - Users should not use these! + ///////////////////////////////////////// + + /// internal, do not use + xed_bool_t emitted; + + /// internal, do not use + unsigned int operand_indx; + + /// internal, do not use + unsigned int skip_operand; + + /// internal, do not use + xed_reg_enum_t extra_index_operand; // for MPX + +} xed_print_info_t; + +// This function initializes the #xed_print_info_t structure. +// You must still set the required fields of that structure. +/// @ingroup PRINT +XED_DLL_EXPORT void xed_init_print_info(xed_print_info_t* pi); + +#endif diff --git a/third_party/xed-intel64/include/xed-reg-class-enum.h b/third_party/xed-intel64/include/xed-reg-class-enum.h new file mode 100644 index 0000000..fe72bd2 --- /dev/null +++ b/third_party/xed-intel64/include/xed-reg-class-enum.h @@ -0,0 +1,84 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-reg-class-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_REG_CLASS_ENUM_H_) +# define _XED_REG_CLASS_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_REG_CLASS_INVALID, + XED_REG_CLASS_BNDCFG, + XED_REG_CLASS_BNDSTAT, + XED_REG_CLASS_BOUND, + XED_REG_CLASS_CR, + XED_REG_CLASS_DR, + XED_REG_CLASS_FLAGS, + XED_REG_CLASS_GPR, + XED_REG_CLASS_GPR16, + XED_REG_CLASS_GPR32, + XED_REG_CLASS_GPR64, + XED_REG_CLASS_GPR8, + XED_REG_CLASS_IP, + XED_REG_CLASS_MASK, + XED_REG_CLASS_MMX, + XED_REG_CLASS_MXCSR, + XED_REG_CLASS_PSEUDO, + XED_REG_CLASS_PSEUDOX87, + XED_REG_CLASS_SR, + XED_REG_CLASS_TMP, + XED_REG_CLASS_X87, + XED_REG_CLASS_XCR, + XED_REG_CLASS_XMM, + XED_REG_CLASS_YMM, + XED_REG_CLASS_ZMM, + XED_REG_CLASS_LAST +} xed_reg_class_enum_t; + +/// This converts strings to #xed_reg_class_enum_t types. +/// @param s A C-string. +/// @return #xed_reg_class_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_reg_class_enum_t str2xed_reg_class_enum_t(const char* s); +/// This converts strings to #xed_reg_class_enum_t types. +/// @param p An enumeration element of type xed_reg_class_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_reg_class_enum_t2str(const xed_reg_class_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_reg_class_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_reg_class_enum_t xed_reg_class_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-reg-class.h b/third_party/xed-intel64/include/xed-reg-class.h new file mode 100644 index 0000000..f9b1690 --- /dev/null +++ b/third_party/xed-intel64/include/xed-reg-class.h @@ -0,0 +1,76 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-reg-class.h +/// + +#ifndef _XED_REG_CLASS_H_ +# define _XED_REG_CLASS_H_ + +#include "../../../third_party/xed-intel64/include/xed-reg-class-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-reg-enum.h" // a generated file +#include "../../../third_party/xed-intel64/include/xed-types.h" + +/// Returns the register class of the given input register. +///@ingroup REGINTFC +XED_DLL_EXPORT xed_reg_class_enum_t xed_reg_class(xed_reg_enum_t r); + +/// Returns the specific width GPR reg class (like XED_REG_CLASS_GPR32 or +/// XED_REG_CLASS_GPR64) +/// for a given GPR register. Or XED_REG_INVALID if not a GPR. +///@ingroup REGINTFC +XED_DLL_EXPORT xed_reg_class_enum_t xed_gpr_reg_class(xed_reg_enum_t r); + +/// Returns the largest enclosing register for any kind of register; This +/// is mostly useful for GPRs. (64b mode assumed) +///@ingroup REGINTFC +XED_DLL_EXPORT xed_reg_enum_t +xed_get_largest_enclosing_register(xed_reg_enum_t r); + +/// Returns the largest enclosing register for any kind of register; This +/// is mostly useful for GPRs in 32b mode. +///@ingroup REGINTFC +XED_DLL_EXPORT xed_reg_enum_t +xed_get_largest_enclosing_register32(xed_reg_enum_t r); + +/// Returns the width, in bits, of the named register. 32b mode +///@ingroup REGINTFC +XED_DLL_EXPORT xed_uint32_t +xed_get_register_width_bits(xed_reg_enum_t r); + +/// Returns the width, in bits, of the named register. 64b mode. +///@ingroup REGINTFC +XED_DLL_EXPORT xed_uint32_t +xed_get_register_width_bits64(xed_reg_enum_t r); + +//////////////////////////////////////////////////////////////////////////// + +#endif diff --git a/third_party/xed-intel64/include/xed-reg-enum.h b/third_party/xed-intel64/include/xed-reg-enum.h new file mode 100644 index 0000000..aae5d6f --- /dev/null +++ b/third_party/xed-intel64/include/xed-reg-enum.h @@ -0,0 +1,389 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-reg-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_REG_ENUM_H_) +# define _XED_REG_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_REG_INVALID, + XED_REG_BNDCFGU, + XED_REG_BNDSTATUS, + XED_REG_BND0, + XED_REG_BND1, + XED_REG_BND2, + XED_REG_BND3, + XED_REG_CR0, + XED_REG_CR1, + XED_REG_CR2, + XED_REG_CR3, + XED_REG_CR4, + XED_REG_CR5, + XED_REG_CR6, + XED_REG_CR7, + XED_REG_CR8, + XED_REG_CR9, + XED_REG_CR10, + XED_REG_CR11, + XED_REG_CR12, + XED_REG_CR13, + XED_REG_CR14, + XED_REG_CR15, + XED_REG_DR0, + XED_REG_DR1, + XED_REG_DR2, + XED_REG_DR3, + XED_REG_DR4, + XED_REG_DR5, + XED_REG_DR6, + XED_REG_DR7, + XED_REG_DR8, + XED_REG_DR9, + XED_REG_DR10, + XED_REG_DR11, + XED_REG_DR12, + XED_REG_DR13, + XED_REG_DR14, + XED_REG_DR15, + XED_REG_FLAGS, + XED_REG_EFLAGS, + XED_REG_RFLAGS, + XED_REG_AX, + XED_REG_CX, + XED_REG_DX, + XED_REG_BX, + XED_REG_SP, + XED_REG_BP, + XED_REG_SI, + XED_REG_DI, + XED_REG_R8W, + XED_REG_R9W, + XED_REG_R10W, + XED_REG_R11W, + XED_REG_R12W, + XED_REG_R13W, + XED_REG_R14W, + XED_REG_R15W, + XED_REG_EAX, + XED_REG_ECX, + XED_REG_EDX, + XED_REG_EBX, + XED_REG_ESP, + XED_REG_EBP, + XED_REG_ESI, + XED_REG_EDI, + XED_REG_R8D, + XED_REG_R9D, + XED_REG_R10D, + XED_REG_R11D, + XED_REG_R12D, + XED_REG_R13D, + XED_REG_R14D, + XED_REG_R15D, + XED_REG_RAX, + XED_REG_RCX, + XED_REG_RDX, + XED_REG_RBX, + XED_REG_RSP, + XED_REG_RBP, + XED_REG_RSI, + XED_REG_RDI, + XED_REG_R8, + XED_REG_R9, + XED_REG_R10, + XED_REG_R11, + XED_REG_R12, + XED_REG_R13, + XED_REG_R14, + XED_REG_R15, + XED_REG_AL, + XED_REG_CL, + XED_REG_DL, + XED_REG_BL, + XED_REG_SPL, + XED_REG_BPL, + XED_REG_SIL, + XED_REG_DIL, + XED_REG_R8B, + XED_REG_R9B, + XED_REG_R10B, + XED_REG_R11B, + XED_REG_R12B, + XED_REG_R13B, + XED_REG_R14B, + XED_REG_R15B, + XED_REG_AH, + XED_REG_CH, + XED_REG_DH, + XED_REG_BH, + XED_REG_ERROR, + XED_REG_RIP, + XED_REG_EIP, + XED_REG_IP, + XED_REG_K0, + XED_REG_K1, + XED_REG_K2, + XED_REG_K3, + XED_REG_K4, + XED_REG_K5, + XED_REG_K6, + XED_REG_K7, + XED_REG_MMX0, + XED_REG_MMX1, + XED_REG_MMX2, + XED_REG_MMX3, + XED_REG_MMX4, + XED_REG_MMX5, + XED_REG_MMX6, + XED_REG_MMX7, + XED_REG_MXCSR, + XED_REG_STACKPUSH, + XED_REG_STACKPOP, + XED_REG_GDTR, + XED_REG_LDTR, + XED_REG_IDTR, + XED_REG_TR, + XED_REG_TSC, + XED_REG_TSCAUX, + XED_REG_MSRS, + XED_REG_FSBASE, + XED_REG_GSBASE, + XED_REG_X87CONTROL, + XED_REG_X87STATUS, + XED_REG_X87TAG, + XED_REG_X87PUSH, + XED_REG_X87POP, + XED_REG_X87POP2, + XED_REG_X87OPCODE, + XED_REG_X87LASTCS, + XED_REG_X87LASTIP, + XED_REG_X87LASTDS, + XED_REG_X87LASTDP, + XED_REG_CS, + XED_REG_DS, + XED_REG_ES, + XED_REG_SS, + XED_REG_FS, + XED_REG_GS, + XED_REG_TMP0, + XED_REG_TMP1, + XED_REG_TMP2, + XED_REG_TMP3, + XED_REG_TMP4, + XED_REG_TMP5, + XED_REG_TMP6, + XED_REG_TMP7, + XED_REG_TMP8, + XED_REG_TMP9, + XED_REG_TMP10, + XED_REG_TMP11, + XED_REG_TMP12, + XED_REG_TMP13, + XED_REG_TMP14, + XED_REG_TMP15, + XED_REG_ST0, + XED_REG_ST1, + XED_REG_ST2, + XED_REG_ST3, + XED_REG_ST4, + XED_REG_ST5, + XED_REG_ST6, + XED_REG_ST7, + XED_REG_XCR0, + XED_REG_XMM0, + XED_REG_XMM1, + XED_REG_XMM2, + XED_REG_XMM3, + XED_REG_XMM4, + XED_REG_XMM5, + XED_REG_XMM6, + XED_REG_XMM7, + XED_REG_XMM8, + XED_REG_XMM9, + XED_REG_XMM10, + XED_REG_XMM11, + XED_REG_XMM12, + XED_REG_XMM13, + XED_REG_XMM14, + XED_REG_XMM15, + XED_REG_XMM16, + XED_REG_XMM17, + XED_REG_XMM18, + XED_REG_XMM19, + XED_REG_XMM20, + XED_REG_XMM21, + XED_REG_XMM22, + XED_REG_XMM23, + XED_REG_XMM24, + XED_REG_XMM25, + XED_REG_XMM26, + XED_REG_XMM27, + XED_REG_XMM28, + XED_REG_XMM29, + XED_REG_XMM30, + XED_REG_XMM31, + XED_REG_YMM0, + XED_REG_YMM1, + XED_REG_YMM2, + XED_REG_YMM3, + XED_REG_YMM4, + XED_REG_YMM5, + XED_REG_YMM6, + XED_REG_YMM7, + XED_REG_YMM8, + XED_REG_YMM9, + XED_REG_YMM10, + XED_REG_YMM11, + XED_REG_YMM12, + XED_REG_YMM13, + XED_REG_YMM14, + XED_REG_YMM15, + XED_REG_YMM16, + XED_REG_YMM17, + XED_REG_YMM18, + XED_REG_YMM19, + XED_REG_YMM20, + XED_REG_YMM21, + XED_REG_YMM22, + XED_REG_YMM23, + XED_REG_YMM24, + XED_REG_YMM25, + XED_REG_YMM26, + XED_REG_YMM27, + XED_REG_YMM28, + XED_REG_YMM29, + XED_REG_YMM30, + XED_REG_YMM31, + XED_REG_ZMM0, + XED_REG_ZMM1, + XED_REG_ZMM2, + XED_REG_ZMM3, + XED_REG_ZMM4, + XED_REG_ZMM5, + XED_REG_ZMM6, + XED_REG_ZMM7, + XED_REG_ZMM8, + XED_REG_ZMM9, + XED_REG_ZMM10, + XED_REG_ZMM11, + XED_REG_ZMM12, + XED_REG_ZMM13, + XED_REG_ZMM14, + XED_REG_ZMM15, + XED_REG_ZMM16, + XED_REG_ZMM17, + XED_REG_ZMM18, + XED_REG_ZMM19, + XED_REG_ZMM20, + XED_REG_ZMM21, + XED_REG_ZMM22, + XED_REG_ZMM23, + XED_REG_ZMM24, + XED_REG_ZMM25, + XED_REG_ZMM26, + XED_REG_ZMM27, + XED_REG_ZMM28, + XED_REG_ZMM29, + XED_REG_ZMM30, + XED_REG_ZMM31, + XED_REG_LAST, + XED_REG_BNDCFG_FIRST=XED_REG_BNDCFGU, //< PSEUDO + XED_REG_BNDCFG_LAST=XED_REG_BNDCFGU, //mmode=arg_mmode; + p->stack_addr_width=arg_stack_addr_width; + (void) arg_ignored; //pacify compiler unused arg warning +} + +/// Constructor. +/// The mode, and addresses widths are enumerations that specify the number +/// of bits. In 64b mode (#XED_MACHINE_MODE_LONG_64) the address width and +/// stack address widths are 64b (#XED_ADDRESS_WIDTH_64b). In other machine +/// modes, you must specify valid addressing widths. +/// +/// @param p the pointer to the #xed_state_t type +/// @param arg_mmode the machine mode of type #xed_machine_mode_enum_t +/// @param arg_stack_addr_width the stack address width of type #xed_address_width_enum_t (only required if not the mode is not #XED_MACHINE_MODE_LONG_64) +/// @ingroup INIT +static XED_INLINE void xed_state_init2(xed_state_t* p, + xed_machine_mode_enum_t arg_mmode, + xed_address_width_enum_t arg_stack_addr_width) { + p->mmode=arg_mmode; + p->stack_addr_width=arg_stack_addr_width; +} + +/// clear the xed_state_t +/// @ingroup INIT +static XED_INLINE void xed_state_zero(xed_state_t* p) { + p->mmode= XED_MACHINE_MODE_INVALID; + p->stack_addr_width=XED_ADDRESS_WIDTH_INVALID; +} + +//@} + +/// @name Machine mode +//@{ +/// return the machine mode +/// @ingroup INIT +static XED_INLINE xed_machine_mode_enum_t xed_state_get_machine_mode(const xed_state_t* p) { + return p->mmode; +} + + +/// true iff the machine is in LONG_64 mode +/// @ingroup INIT +static XED_INLINE xed_bool_t xed_state_long64_mode(const xed_state_t* p) { + return xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_64; +} + +/// @ingroup INIT +static XED_INLINE xed_bool_t xed_state_real_mode(const xed_state_t* p) { + return (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_REAL_16); +} + +/// @ingroup INIT +static XED_INLINE xed_bool_t xed_state_mode_width_16(const xed_state_t* p) { + return (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LEGACY_16) || + (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_COMPAT_16); +} + +/// @ingroup INIT +static XED_INLINE xed_bool_t xed_state_mode_width_32(const xed_state_t* p) { + return (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LEGACY_32) || + (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_COMPAT_32); +} + + +/// Set the machine mode which corresponds to the default data operand size +/// @ingroup INIT +static XED_INLINE void xed_state_set_machine_mode( xed_state_t* p, + xed_machine_mode_enum_t arg_mode) { + p->mmode = arg_mode; +} +//@} + +/// @name Address width +//@{ + +/// return the address width +/// @ingroup INIT +static XED_INLINE xed_address_width_enum_t +xed_state_get_address_width(const xed_state_t* p) +{ + switch(xed_state_get_machine_mode(p)) { + case XED_MACHINE_MODE_LONG_64: + return XED_ADDRESS_WIDTH_64b; + + case XED_MACHINE_MODE_REAL_16: + /* should be 20b... but if you are working w/real mode then you're + going to have to deal with somehow. Could easily make this be + 20b if anyone cares. */ + return XED_ADDRESS_WIDTH_32b; + + case XED_MACHINE_MODE_LEGACY_32: + case XED_MACHINE_MODE_LONG_COMPAT_32: + return XED_ADDRESS_WIDTH_32b; + case XED_MACHINE_MODE_LEGACY_16: + case XED_MACHINE_MODE_LONG_COMPAT_16: + return XED_ADDRESS_WIDTH_16b; + default: + return XED_ADDRESS_WIDTH_INVALID; + } +} + +//@} + +/// @name Stack address width +//@{ +/// set the STACK address width +/// @ingroup INIT +static XED_INLINE void +xed_state_set_stack_address_width(xed_state_t* p, + xed_address_width_enum_t arg_addr_width) +{ + p->stack_addr_width = arg_addr_width; +} + + +/// Return the STACK address width +/// @ingroup INIT +static XED_INLINE xed_address_width_enum_t xed_state_get_stack_address_width(const xed_state_t* p) { + return p->stack_addr_width; +} +//@} + +/// @ingroup INIT +XED_DLL_EXPORT int xed_state_print(const xed_state_t* p, char* buf, int buflen); + +#endif + diff --git a/third_party/xed-intel64/include/xed-syntax-enum.h b/third_party/xed-intel64/include/xed-syntax-enum.h new file mode 100644 index 0000000..ee19909 --- /dev/null +++ b/third_party/xed-intel64/include/xed-syntax-enum.h @@ -0,0 +1,63 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-syntax-enum.h + +// This file was automatically generated. +// Do not edit this file. + +#if !defined(_XED_SYNTAX_ENUM_H_) +# define _XED_SYNTAX_ENUM_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +typedef enum { + XED_SYNTAX_INVALID, + XED_SYNTAX_XED, ///< XED disassembly syntax + XED_SYNTAX_ATT, ///< ATT SYSV disassembly syntax + XED_SYNTAX_INTEL, ///< Intel disassembly syntax + XED_SYNTAX_LAST +} xed_syntax_enum_t; + +/// This converts strings to #xed_syntax_enum_t types. +/// @param s A C-string. +/// @return #xed_syntax_enum_t +/// @ingroup ENUM +XED_DLL_EXPORT xed_syntax_enum_t str2xed_syntax_enum_t(const char* s); +/// This converts strings to #xed_syntax_enum_t types. +/// @param p An enumeration element of type xed_syntax_enum_t. +/// @return string +/// @ingroup ENUM +XED_DLL_EXPORT const char* xed_syntax_enum_t2str(const xed_syntax_enum_t p); + +/// Returns the last element of the enumeration +/// @return xed_syntax_enum_t The last element of the enumeration. +/// @ingroup ENUM +XED_DLL_EXPORT xed_syntax_enum_t xed_syntax_enum_t_last(void); +#endif diff --git a/third_party/xed-intel64/include/xed-types.h b/third_party/xed-intel64/include/xed-types.h new file mode 100644 index 0000000..ce267cd --- /dev/null +++ b/third_party/xed-intel64/include/xed-types.h @@ -0,0 +1,138 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-types.h +/// + + +#ifndef _XED_TYPES_H_ +# define _XED_TYPES_H_ + +//////////////////////////////////////////////////////////////////////////// + +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" + +#if defined(__GNUC__) || defined(__ICC) +# include +# define xed_uint8_t uint8_t +# define xed_uint16_t uint16_t +# define xed_uint32_t uint32_t +# define xed_uint64_t uint64_t +# define xed_int8_t int8_t +# define xed_int16_t int16_t +# define xed_int32_t int32_t +# define xed_int64_t int64_t +#elif defined(_WIN32) +# define xed_uint8_t unsigned __int8 +# define xed_uint16_t unsigned __int16 +# define xed_uint32_t unsigned __int32 +# define xed_uint64_t unsigned __int64 +# define xed_int8_t __int8 +# define xed_int16_t __int16 +# define xed_int32_t __int32 +# define xed_int64_t __int64 +#else +# error "XED types unsupported platform? Need windows, gcc, or icc." +#endif + +typedef unsigned int xed_uint_t; +typedef int xed_int_t; +typedef unsigned int xed_bits_t; +typedef unsigned int xed_bool_t; + +typedef union { + xed_uint8_t byte[2]; + xed_int8_t s_byte[2]; + + struct { + xed_uint8_t b0; /*low 8 bits*/ + xed_uint8_t b1; /*high 8 bits*/ + } b; + xed_int16_t i16; + xed_uint16_t u16; +} xed_union16_t ; + +typedef union { + xed_uint8_t byte[4]; + xed_uint16_t word[2]; + xed_int8_t s_byte[4]; + xed_int16_t s_word[2]; + + struct { + xed_uint8_t b0; /*low 8 bits*/ + xed_uint8_t b1; + xed_uint8_t b2; + xed_uint8_t b3; /*high 8 bits*/ + } b; + + struct { + xed_uint16_t w0; /*low 16 bits*/ + xed_uint16_t w1; /*high 16 bits*/ + } w; + xed_int32_t i32; + xed_uint32_t u32; +} xed_union32_t ; + +typedef union { + xed_uint8_t byte[8]; + xed_uint16_t word[4]; + xed_uint32_t dword[2]; + xed_int8_t s_byte[8]; + xed_int16_t s_word[4]; + xed_int32_t s_dword[2]; + + struct { + xed_uint8_t b0; /*low 8 bits*/ + xed_uint8_t b1; + xed_uint8_t b2; + xed_uint8_t b3; + xed_uint8_t b4; + xed_uint8_t b5; + xed_uint8_t b6; + xed_uint8_t b7; /*high 8 bits*/ + } b; + + struct { + xed_uint16_t w0; /*low 16 bits*/ + xed_uint16_t w1; + xed_uint16_t w2; + xed_uint16_t w3; /*high 16 bits*/ + } w; + struct { + xed_uint32_t lo32; + xed_uint32_t hi32; + } s; + xed_uint64_t u64; + xed_int64_t i64; +} xed_union64_t ; + +//////////////////////////////////////////////////////////////////////////// +#endif diff --git a/third_party/xed-intel64/include/xed-util.h b/third_party/xed-intel64/include/xed-util.h new file mode 100644 index 0000000..7ca7b2f --- /dev/null +++ b/third_party/xed-intel64/include/xed-util.h @@ -0,0 +1,291 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-util.h +/// + + + +#ifndef _XED_UTIL_H_ +# define _XED_UTIL_H_ + +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" +#include "../../../third_party/xed-intel64/include/xed-portability.h" +#include "../../../third_party/xed-intel64/include/xed-types.h" + + +//////////////////////////////////////////////////////////////////////////// +// DEFINES +//////////////////////////////////////////////////////////////////////////// +extern int xed_verbose; +#if defined(XED_MESSAGES) +# include +extern FILE* xed_log_file; +# define XED_EMIT_MESSAGES (xed_verbose >= 1) +# define XED_INFO_VERBOSE (xed_verbose >= 2) +# define XED_INFO2_VERBOSE (xed_verbose >= 3) +# define XED_VERBOSE (xed_verbose >= 4) +# define XED_MORE_VERBOSE (xed_verbose >= 5) +# define XED_VERY_VERBOSE (xed_verbose >= 6) +#else +# define XED_EMIT_MESSAGES (0) +# define XED_INFO_VERBOSE (0) +# define XED_INFO2_VERBOSE (0) +# define XED_VERBOSE (0) +# define XED_MORE_VERBOSE (0) +# define XED_VERY_VERBOSE (0) +#endif + +#if defined(__GNUC__) +# define XED_FUNCNAME __func__ +#else +# define XED_FUNCNAME "" +#endif + +#if defined(XED_MESSAGES) +#define XED2IMSG(x) \ + do { \ + if (XED_EMIT_MESSAGES) { \ + if (XED_VERY_VERBOSE) { \ + fprintf(xed_log_file,"%s:%d:%s: ", \ + __FILE__, __LINE__, XED_FUNCNAME); \ + } \ + fprintf x; \ + fflush(xed_log_file); \ + } \ + } while(0) + +#define XED2TMSG(x) \ + do { \ + if (XED_VERBOSE) { \ + if (XED_VERY_VERBOSE) { \ + fprintf(xed_log_file,"%s:%d:%s: ", \ + __FILE__, __LINE__, XED_FUNCNAME); \ + } \ + fprintf x; \ + fflush(xed_log_file); \ + } \ + } while(0) + +#define XED2VMSG(x) \ + do { \ + if (XED_VERY_VERBOSE) { \ + fprintf(xed_log_file,"%s:%d:%s: ", \ + __FILE__, __LINE__, XED_FUNCNAME); \ + fprintf x; \ + fflush(xed_log_file); \ + } \ + } while(0) + +#define XED2DIE(x) \ + do { \ + if (XED_EMIT_MESSAGES) { \ + fprintf(xed_log_file,"%s:%d:%s: ", \ + __FILE__, __LINE__, XED_FUNCNAME); \ + fprintf x; \ + fflush(xed_log_file); \ + } \ + xed_assert(0); \ + } while(0) + + + +#else +# define XED2IMSG(x) +# define XED2TMSG(x) +# define XED2VMSG(x) +# define XED2DIE(x) do { xed_assert(0); } while(0) +#endif + +#if defined(XED_ASSERTS) +# define xed_assert(x) do { if (( x )== 0) xed_internal_assert( #x, __FILE__, __LINE__); } while(0) +#else +# define xed_assert(x) do { } while(0) +#endif +XED_NORETURN XED_NOINLINE XED_DLL_EXPORT void xed_internal_assert(const char* s, const char* file, int line); + +typedef void (*xed_user_abort_function_t)(const char* msg, + const char* file, + int line, + void* other); + +/// @ingroup INIT +/// This is for registering a function to be called during XED's assert +/// processing. If you do not register an abort function, then the system's +/// abort function will be called. If your supplied function returns, then +/// abort() will still be called. +/// +/// @param fn This is a function pointer for a function that should handle the +/// assertion reporting. The function pointer points to a function that +/// takes 4 arguments: +/// (1) msg, the assertion message, +/// (2) file, the file name, +/// (3) line, the line number (as an integer), and +/// (4) other, a void pointer that is supplied as thei +/// 2nd argument to this registration. +/// @param other This is a void* that is passed back to your supplied function fn +/// as its 4th argument. It can be zero if you don't need this +/// feature. You can used this to convey whatever additional context +/// to your assertion handler (like FILE* pointers etc.). +/// +XED_DLL_EXPORT void xed_register_abort_function(xed_user_abort_function_t fn, + void* other); + + +//////////////////////////////////////////////////////////////////////////// +// PROTOTYPES +//////////////////////////////////////////////////////////////////////////// +char* xed_downcase_buf(char* s); + +/* copy from src to dst, downcasing bytes as the copy proceeds. len is the + * available space in the buffer*/ +int xed_strncat_lower(char* dst, const char* src, int len); + +XED_DLL_EXPORT int xed_itoa(char* buf, + xed_uint64_t f, + int buflen); + +int xed_itoa_hex_zeros(char* buf, + xed_uint64_t f, + xed_uint_t xed_bits_to_print, + xed_bool_t leading_zeros, + int buflen); + +XED_DLL_EXPORT int xed_itoa_hex(char* buf, + xed_uint64_t f, + xed_uint_t xed_bits_to_print, + int buflen); + +int xed_itoa_signed(char* buf, xed_int64_t f, int buflen); + +char xed_to_ascii_hex_nibble(xed_uint_t x); + +int xed_sprintf_uint8_hex(char* buf, xed_uint8_t x, int buflen); +int xed_sprintf_uint16_hex(char* buf, xed_uint16_t x, int buflen); +int xed_sprintf_uint32_hex(char* buf, xed_uint32_t x, int buflen); +int xed_sprintf_uint64_hex(char* buf, xed_uint64_t x, int buflen); +int xed_sprintf_uint8(char* buf, xed_uint8_t x, int buflen); +int xed_sprintf_uint16(char* buf, xed_uint16_t x, int buflen); +int xed_sprintf_uint32(char* buf, xed_uint32_t x, int buflen); +int xed_sprintf_uint64(char* buf, xed_uint64_t x, int buflen); +int xed_sprintf_int8(char* buf, xed_int8_t x, int buflen); +int xed_sprintf_int16(char* buf, xed_int16_t x, int buflen); +int xed_sprintf_int32(char* buf, xed_int32_t x, int buflen); +int xed_sprintf_int64(char* buf, xed_int64_t x, int buflen); + +/// Set the FILE* for XED's log msgs. This takes a FILE* as a void* because +/// some software defines their own FILE* types creating conflicts. +XED_DLL_EXPORT void xed_set_log_file(void* o); + + +/// Set the verbosity level for XED +XED_DLL_EXPORT void xed_set_verbosity(int v); + +void xed_derror(const char* s); +void xed_dwarn(const char* s); + +XED_DLL_EXPORT xed_int64_t xed_sign_extend32_64(xed_int32_t x); +XED_DLL_EXPORT xed_int64_t xed_sign_extend16_64(xed_int16_t x); +XED_DLL_EXPORT xed_int64_t xed_sign_extend8_64(xed_int8_t x); + +XED_DLL_EXPORT xed_int32_t xed_sign_extend16_32(xed_int16_t x); +XED_DLL_EXPORT xed_int32_t xed_sign_extend8_32(xed_int8_t x); + +XED_DLL_EXPORT xed_int16_t xed_sign_extend8_16(xed_int8_t x); + +///arbitrary sign extension from a qty of "bits" length to 32b +XED_DLL_EXPORT xed_int32_t xed_sign_extend_arbitrary_to_32(xed_uint32_t x, unsigned int bits); + +///arbitrary sign extension from a qty of "bits" length to 64b +XED_DLL_EXPORT xed_int64_t xed_sign_extend_arbitrary_to_64(xed_uint64_t x, unsigned int bits); + + +XED_DLL_EXPORT xed_uint64_t xed_zero_extend32_64(xed_uint32_t x); +XED_DLL_EXPORT xed_uint64_t xed_zero_extend16_64(xed_uint16_t x); +XED_DLL_EXPORT xed_uint64_t xed_zero_extend8_64(xed_uint8_t x); + +XED_DLL_EXPORT xed_uint32_t xed_zero_extend16_32(xed_uint16_t x); +XED_DLL_EXPORT xed_uint32_t xed_zero_extend8_32(xed_uint8_t x); + +XED_DLL_EXPORT xed_uint16_t xed_zero_extend8_16(xed_uint8_t x); + +#if defined(XED_LITTLE_ENDIAN_SWAPPING) +XED_DLL_EXPORT xed_int32_t +xed_little_endian_to_int32(xed_uint64_t x, unsigned int len); + +XED_DLL_EXPORT xed_int64_t +xed_little_endian_to_int64(xed_uint64_t x, unsigned int len); +XED_DLL_EXPORT xed_uint64_t +xed_little_endian_to_uint64(xed_uint64_t x, unsigned int len); + +XED_DLL_EXPORT xed_int64_t +xed_little_endian_hilo_to_int64(xed_uint32_t hi_le, xed_uint32_t lo_le, unsigned int len); +XED_DLL_EXPORT xed_uint64_t +xed_little_endian_hilo_to_uint64(xed_uint32_t hi_le, xed_uint32_t lo_le, unsigned int len); +#endif + +XED_DLL_EXPORT xed_uint8_t +xed_get_byte(xed_uint64_t x, unsigned int i, unsigned int len); + +static XED_INLINE xed_uint64_t xed_make_uint64(xed_uint32_t hi, xed_uint32_t lo) { + xed_union64_t y; + y.s.lo32= lo; + y.s.hi32= hi; + return y.u64; +} +static XED_INLINE xed_int64_t xed_make_int64(xed_uint32_t hi, xed_uint32_t lo) { + xed_union64_t y; + y.s.lo32= lo; + y.s.hi32= hi; + return y.i64; +} + +/// returns the number of bytes required to store the UNSIGNED number x +/// given a mask of legal lengths. For the legal_widths argument, bit 0 +/// implies 1 byte is a legal return width, bit 1 implies that 2 bytes is a +/// legal return width, bit 2 implies that 4 bytes is a legal return width. +/// This returns 8 (indicating 8B) if none of the provided legal widths +/// applies. +XED_DLL_EXPORT xed_uint_t xed_shortest_width_unsigned(xed_uint64_t x, xed_uint8_t legal_widths); + +/// returns the number of bytes required to store the SIGNED number x +/// given a mask of legal lengths. For the legal_widths argument, bit 0 implies 1 +/// byte is a legal return width, bit 1 implies that 2 bytes is a legal +/// return width, bit 2 implies that 4 bytes is a legal return width. This +/// returns 8 (indicating 8B) if none of the provided legal widths applies. +XED_DLL_EXPORT xed_uint_t xed_shortest_width_signed(xed_int64_t x, xed_uint8_t legal_widths); + +//////////////////////////////////////////////////////////////////////////// +// GLOBALS +//////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////// +#endif diff --git a/third_party/xed-intel64/include/xed-version.h b/third_party/xed-intel64/include/xed-version.h new file mode 100644 index 0000000..8e7e7ea --- /dev/null +++ b/third_party/xed-intel64/include/xed-version.h @@ -0,0 +1,43 @@ +/*BEGIN_LEGAL +Copyright (c) 2004-2015, Intel Corporation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Intel Corporation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ + +#if !defined(_XED_VERSION_H_) +# define _XED_VERSION_H_ +#include "../../../third_party/xed-intel64/include/xed-common-hdrs.h" + +///@ingroup INIT +/// Returns a string representing XED svn commit revision and time stamp. +XED_DLL_EXPORT char const* xed_get_version(void); +///@ingroup INIT +/// Returns a copyright string. +XED_DLL_EXPORT char const* xed_get_copyright(void); +#endif diff --git a/third_party/xed-intel64/lib/libxed.a b/third_party/xed-intel64/lib/libxed.a new file mode 100644 index 0000000..64beb45 Binary files /dev/null and b/third_party/xed-intel64/lib/libxed.a differ diff --git a/third_party/xed-intel64/redist.txt b/third_party/xed-intel64/redist.txt new file mode 100644 index 0000000..46f7da6 --- /dev/null +++ b/third_party/xed-intel64/redist.txt @@ -0,0 +1,12 @@ +This file is redist.txt. + +The following files, if present, are allowed to be redistributed via +compilation, static linking or dynamic linking, subject to the terms +of the license found in the LICENSE.txt file: + +libxed.a +libxed.lib +libxed.so +libxed.dll +libxed.dylib + diff --git a/third_party/xxhash/LICENSE b/third_party/xxhash/LICENSE new file mode 100644 index 0000000..b4d8fc3 --- /dev/null +++ b/third_party/xxhash/LICENSE @@ -0,0 +1,24 @@ +xxHash Library +Copyright (c) 2012-2014, Yann Collet +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/third_party/xxhash/xxhash.c b/third_party/xxhash/xxhash.c new file mode 100644 index 0000000..eb59950 --- /dev/null +++ b/third_party/xxhash/xxhash.c @@ -0,0 +1,923 @@ +/* +xxHash - Fast Hash algorithm +Copyright (C) 2012-2014, Yann Collet. +BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +You can contact the author at : +- xxHash source repository : http://code.google.com/p/xxhash/ +- public discussion board : https://groups.google.com/forum/#!forum/lz4c +*/ + + +//************************************** +// Tuning parameters +//************************************** +// Unaligned memory access is automatically enabled for "common" CPU, such as x86. +// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected. +// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance. +// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32). +#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) +# define XXH_USE_UNALIGNED_ACCESS 1 +#endif + +// XXH_ACCEPT_NULL_INPUT_POINTER : +// If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. +// When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. +// This option has a very small performance cost (only measurable on small inputs). +// By default, this option is disabled. To enable it, uncomment below define : +// #define XXH_ACCEPT_NULL_INPUT_POINTER 1 + +// XXH_FORCE_NATIVE_FORMAT : +// By default, xxHash library provides endian-independant Hash values, based on little-endian convention. +// Results are therefore identical for little-endian and big-endian CPU. +// This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. +// Should endian-independance be of no importance for your application, you may set the #define below to 1. +// It will improve speed for Big-endian CPU. +// This option has no impact on Little_Endian CPU. +#define XXH_FORCE_NATIVE_FORMAT 1 + +//************************************** +// Compiler Specific Options +//************************************** +// Disable some Visual warning messages +#ifdef _MSC_VER // Visual Studio +# pragma warning(disable : 4127) // disable: C4127: conditional expression is constant +#endif + +#ifdef _MSC_VER // Visual Studio +# define FORCE_INLINE static __forceinline +#else +# ifdef __GNUC__ +# define FORCE_INLINE static inline __attribute__((always_inline)) +# else +# define FORCE_INLINE static inline +# endif +#endif + +//************************************** +// Includes & Memory related functions +//************************************** +#include "../../third_party/xxhash/xxhash.h" +// Modify the local functions below should you wish to use some other memory routines +// for malloc(), free() +#include +static void* XXH_malloc(size_t s) { return malloc(s); } +static void XXH_free (void* p) { free(p); } +// for memcpy() +#include +static void* XXH_memcpy(void* dest, const void* src, size_t size) +{ + return memcpy(dest,src,size); +} + + +//************************************** +// Basic Types +//************************************** +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L // C99 +# include +typedef uint8_t BYTE; +typedef uint16_t U16; +typedef uint32_t U32; +typedef int32_t S32; +typedef uint64_t U64; +#else +typedef unsigned char BYTE; +typedef unsigned short U16; +typedef unsigned int U32; +typedef signed int S32; +typedef unsigned long long U64; +#endif + +#if defined(__GNUC__) && !defined(XXH_USE_UNALIGNED_ACCESS) +# define _PACKED __attribute__ ((packed)) +#else +# define _PACKED +#endif + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# ifdef __IBMC__ +# pragma pack(1) +# else +# pragma pack(push, 1) +# endif +#endif + +typedef struct _U32_S +{ + U32 v; +} _PACKED U32_S; +typedef struct _U64_S +{ + U64 v; +} _PACKED U64_S; + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# pragma pack(pop) +#endif + +#define A32(x) (((U32_S *)(x))->v) +#define A64(x) (((U64_S *)(x))->v) + + +//*************************************** +// Compiler-specific Functions and Macros +//*************************************** +#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) + +// Note : although _rotl exists for minGW (GCC under windows), performance seems poor +#if defined(_MSC_VER) +# define XXH_rotl32(x,r) _rotl(x,r) +# define XXH_rotl64(x,r) _rotl64(x,r) +#else +# define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) +# define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r))) +#endif + +#if defined(_MSC_VER) // Visual Studio +# define XXH_swap32 _byteswap_ulong +# define XXH_swap64 _byteswap_uint64 +#elif GCC_VERSION >= 403 +# define XXH_swap32 __builtin_bswap32 +# define XXH_swap64 __builtin_bswap64 +#else +static inline U32 XXH_swap32 (U32 x) +{ + return ((x << 24) & 0xff000000 ) | + ((x << 8) & 0x00ff0000 ) | + ((x >> 8) & 0x0000ff00 ) | + ((x >> 24) & 0x000000ff ); +} +static inline U64 XXH_swap64 (U64 x) +{ + return ((x << 56) & 0xff00000000000000ULL) | + ((x << 40) & 0x00ff000000000000ULL) | + ((x << 24) & 0x0000ff0000000000ULL) | + ((x << 8) & 0x000000ff00000000ULL) | + ((x >> 8) & 0x00000000ff000000ULL) | + ((x >> 24) & 0x0000000000ff0000ULL) | + ((x >> 40) & 0x000000000000ff00ULL) | + ((x >> 56) & 0x00000000000000ffULL); +} +#endif + + +//************************************** +// Constants +//************************************** +#define PRIME32_1 2654435761U +#define PRIME32_2 2246822519U +#define PRIME32_3 3266489917U +#define PRIME32_4 668265263U +#define PRIME32_5 374761393U + +#define PRIME64_1 11400714785074694791ULL +#define PRIME64_2 14029467366897019727ULL +#define PRIME64_3 1609587929392839161ULL +#define PRIME64_4 9650029242287828579ULL +#define PRIME64_5 2870177450012600261ULL + +//************************************** +// Architecture Macros +//************************************** +typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; +#ifndef XXH_CPU_LITTLE_ENDIAN // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch +static const int one = 1; +# define XXH_CPU_LITTLE_ENDIAN (*(char*)(&one)) +#endif + + +//************************************** +// Macros +//************************************** +#define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(!!(c)) }; } // use only *after* variable declarations + + +//**************************** +// Memory reads +//**************************** +typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; + +FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align) +{ + if (align==XXH_unaligned) + return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr)); + else + return endian==XXH_littleEndian ? *(U32*)ptr : XXH_swap32(*(U32*)ptr); +} + +FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian) +{ + return XXH_readLE32_align(ptr, endian, XXH_unaligned); +} + +FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align) +{ + if (align==XXH_unaligned) + return endian==XXH_littleEndian ? A64(ptr) : XXH_swap64(A64(ptr)); + else + return endian==XXH_littleEndian ? *(U64*)ptr : XXH_swap64(*(U64*)ptr); +} + +FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian) +{ + return XXH_readLE64_align(ptr, endian, XXH_unaligned); +} + + +//**************************** +// Simple Hash Functions +//**************************** +FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align) +{ + const BYTE* p = (const BYTE*)input; + const BYTE* bEnd = p + len; + U32 h32; +#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align) + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (p==NULL) + { + len=0; + bEnd=p=(const BYTE*)(size_t)16; + } +#endif + + if (len>=16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = seed + PRIME32_1 + PRIME32_2; + U32 v2 = seed + PRIME32_2; + U32 v3 = seed + 0; + U32 v4 = seed - PRIME32_1; + + do + { + v1 += XXH_get32bits(p) * PRIME32_2; + v1 = XXH_rotl32(v1, 13); + v1 *= PRIME32_1; + p+=4; + v2 += XXH_get32bits(p) * PRIME32_2; + v2 = XXH_rotl32(v2, 13); + v2 *= PRIME32_1; + p+=4; + v3 += XXH_get32bits(p) * PRIME32_2; + v3 = XXH_rotl32(v3, 13); + v3 *= PRIME32_1; + p+=4; + v4 += XXH_get32bits(p) * PRIME32_2; + v4 = XXH_rotl32(v4, 13); + v4 *= PRIME32_1; + p+=4; + } + while (p<=limit); + + h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); + } + else + { + h32 = seed + PRIME32_5; + } + + h32 += (U32) len; + + while (p+4<=bEnd) + { + h32 += XXH_get32bits(p) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4 ; + p+=4; + } + + while (p> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + + +unsigned int XXH32 (const void* input, size_t len, unsigned seed) +{ +#if 0 + // Simple version, good for code maintenance, but unfortunately slow for small inputs + XXH32_state_t state; + XXH32_reset(&state, seed); + XXH32_update(&state, input, len); + return XXH32_digest(&state); +#else + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + +# if !defined(XXH_USE_UNALIGNED_ACCESS) + if ((((size_t)input) & 3) == 0) // Input is aligned, let's leverage the speed advantage + { + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); + } +# endif + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); +#endif +} + +FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align) +{ + const BYTE* p = (const BYTE*)input; + const BYTE* bEnd = p + len; + U64 h64; +#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align) + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (p==NULL) + { + len=0; + bEnd=p=(const BYTE*)(size_t)32; + } +#endif + + if (len>=32) + { + const BYTE* const limit = bEnd - 32; + U64 v1 = seed + PRIME64_1 + PRIME64_2; + U64 v2 = seed + PRIME64_2; + U64 v3 = seed + 0; + U64 v4 = seed - PRIME64_1; + + do + { + v1 += XXH_get64bits(p) * PRIME64_2; + p+=8; + v1 = XXH_rotl64(v1, 31); + v1 *= PRIME64_1; + v2 += XXH_get64bits(p) * PRIME64_2; + p+=8; + v2 = XXH_rotl64(v2, 31); + v2 *= PRIME64_1; + v3 += XXH_get64bits(p) * PRIME64_2; + p+=8; + v3 = XXH_rotl64(v3, 31); + v3 *= PRIME64_1; + v4 += XXH_get64bits(p) * PRIME64_2; + p+=8; + v4 = XXH_rotl64(v4, 31); + v4 *= PRIME64_1; + } + while (p<=limit); + + h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); + + v1 *= PRIME64_2; + v1 = XXH_rotl64(v1, 31); + v1 *= PRIME64_1; + h64 ^= v1; + h64 = h64 * PRIME64_1 + PRIME64_4; + + v2 *= PRIME64_2; + v2 = XXH_rotl64(v2, 31); + v2 *= PRIME64_1; + h64 ^= v2; + h64 = h64 * PRIME64_1 + PRIME64_4; + + v3 *= PRIME64_2; + v3 = XXH_rotl64(v3, 31); + v3 *= PRIME64_1; + h64 ^= v3; + h64 = h64 * PRIME64_1 + PRIME64_4; + + v4 *= PRIME64_2; + v4 = XXH_rotl64(v4, 31); + v4 *= PRIME64_1; + h64 ^= v4; + h64 = h64 * PRIME64_1 + PRIME64_4; + } + else + { + h64 = seed + PRIME64_5; + } + + h64 += (U64) len; + + while (p+8<=bEnd) + { + U64 k1 = XXH_get64bits(p); + k1 *= PRIME64_2; + k1 = XXH_rotl64(k1,31); + k1 *= PRIME64_1; + h64 ^= k1; + h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; + p+=8; + } + + if (p+4<=bEnd) + { + h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; + h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; + p+=4; + } + + while (p> 33; + h64 *= PRIME64_2; + h64 ^= h64 >> 29; + h64 *= PRIME64_3; + h64 ^= h64 >> 32; + + return h64; +} + + +unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed) +{ +#if 0 + // Simple version, good for code maintenance, but unfortunately slow for small inputs + XXH64_state_t state; + XXH64_reset(&state, seed); + XXH64_update(&state, input, len); + return XXH64_digest(&state); +#else + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + +# if !defined(XXH_USE_UNALIGNED_ACCESS) + if ((((size_t)input) & 7)==0) // Input is aligned, let's leverage the speed advantage + { + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); + else + return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); + } +# endif + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); + else + return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); +#endif +} + +/**************************************************** + * Advanced Hash Functions +****************************************************/ + +/*** Allocation ***/ +typedef struct +{ + U64 total_len; + U32 seed; + U32 v1; + U32 v2; + U32 v3; + U32 v4; + U32 mem32[4]; /* defined as U32 for alignment */ + U32 memsize; +} XXH_istate32_t; + +typedef struct +{ + U64 total_len; + U64 seed; + U64 v1; + U64 v2; + U64 v3; + U64 v4; + U64 mem64[4]; /* defined as U64 for alignment */ + U32 memsize; +} XXH_istate64_t; + + +XXH32_state_t* XXH32_createState(void) +{ + XXH_STATIC_ASSERT(sizeof(XXH32_state_t) >= sizeof(XXH_istate32_t)); // A compilation error here means XXH32_state_t is not large enough + return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t)); +} +XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr) +{ + XXH_free(statePtr); + return XXH_OK; +} + +XXH64_state_t* XXH64_createState(void) +{ + XXH_STATIC_ASSERT(sizeof(XXH64_state_t) >= sizeof(XXH_istate64_t)); // A compilation error here means XXH64_state_t is not large enough + return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t)); +} +XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr) +{ + XXH_free(statePtr); + return XXH_OK; +} + + +/*** Hash feed ***/ + +XXH_errorcode XXH32_reset(XXH32_state_t* state_in, U32 seed) +{ + XXH_istate32_t* state = (XXH_istate32_t*) state_in; + state->seed = seed; + state->v1 = seed + PRIME32_1 + PRIME32_2; + state->v2 = seed + PRIME32_2; + state->v3 = seed + 0; + state->v4 = seed - PRIME32_1; + state->total_len = 0; + state->memsize = 0; + return XXH_OK; +} + +XXH_errorcode XXH64_reset(XXH64_state_t* state_in, unsigned long long seed) +{ + XXH_istate64_t* state = (XXH_istate64_t*) state_in; + state->seed = seed; + state->v1 = seed + PRIME64_1 + PRIME64_2; + state->v2 = seed + PRIME64_2; + state->v3 = seed + 0; + state->v4 = seed - PRIME64_1; + state->total_len = 0; + state->memsize = 0; + return XXH_OK; +} + + +FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state_in, const void* input, size_t len, XXH_endianess endian) +{ + XXH_istate32_t* state = (XXH_istate32_t *) state_in; + const BYTE* p = (const BYTE*)input; + const BYTE* const bEnd = p + len; + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (input==NULL) return XXH_ERROR; +#endif + + state->total_len += len; + + if (state->memsize + len < 16) // fill in tmp buffer + { + XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len); + state->memsize += (U32)len; + return XXH_OK; + } + + if (state->memsize) // some data left from previous update + { + XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize); + { + const U32* p32 = state->mem32; + state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; + state->v1 = XXH_rotl32(state->v1, 13); + state->v1 *= PRIME32_1; + p32++; + state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; + state->v2 = XXH_rotl32(state->v2, 13); + state->v2 *= PRIME32_1; + p32++; + state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; + state->v3 = XXH_rotl32(state->v3, 13); + state->v3 *= PRIME32_1; + p32++; + state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; + state->v4 = XXH_rotl32(state->v4, 13); + state->v4 *= PRIME32_1; + p32++; + } + p += 16-state->memsize; + state->memsize = 0; + } + + if (p <= bEnd-16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = state->v1; + U32 v2 = state->v2; + U32 v3 = state->v3; + U32 v4 = state->v4; + + do + { + v1 += XXH_readLE32(p, endian) * PRIME32_2; + v1 = XXH_rotl32(v1, 13); + v1 *= PRIME32_1; + p+=4; + v2 += XXH_readLE32(p, endian) * PRIME32_2; + v2 = XXH_rotl32(v2, 13); + v2 *= PRIME32_1; + p+=4; + v3 += XXH_readLE32(p, endian) * PRIME32_2; + v3 = XXH_rotl32(v3, 13); + v3 *= PRIME32_1; + p+=4; + v4 += XXH_readLE32(p, endian) * PRIME32_2; + v4 = XXH_rotl32(v4, 13); + v4 *= PRIME32_1; + p+=4; + } + while (p<=limit); + + state->v1 = v1; + state->v2 = v2; + state->v3 = v3; + state->v4 = v4; + } + + if (p < bEnd) + { + XXH_memcpy(state->mem32, p, bEnd-p); + state->memsize = (int)(bEnd-p); + } + + return XXH_OK; +} + +XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_update_endian(state_in, input, len, XXH_littleEndian); + else + return XXH32_update_endian(state_in, input, len, XXH_bigEndian); +} + + + +FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state_in, XXH_endianess endian) +{ + XXH_istate32_t* state = (XXH_istate32_t*) state_in; + const BYTE * p = (const BYTE*)state->mem32; + BYTE* bEnd = (BYTE*)(state->mem32) + state->memsize; + U32 h32; + + if (state->total_len >= 16) + { + h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); + } + else + { + h32 = state->seed + PRIME32_5; + } + + h32 += (U32) state->total_len; + + while (p+4<=bEnd) + { + h32 += XXH_readLE32(p, endian) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4; + p+=4; + } + + while (p> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + + +U32 XXH32_digest (const XXH32_state_t* state_in) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_digest_endian(state_in, XXH_littleEndian); + else + return XXH32_digest_endian(state_in, XXH_bigEndian); +} + + +FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state_in, const void* input, size_t len, XXH_endianess endian) +{ + XXH_istate64_t * state = (XXH_istate64_t *) state_in; + const BYTE* p = (const BYTE*)input; + const BYTE* const bEnd = p + len; + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (input==NULL) return XXH_ERROR; +#endif + + state->total_len += len; + + if (state->memsize + len < 32) // fill in tmp buffer + { + XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len); + state->memsize += (U32)len; + return XXH_OK; + } + + if (state->memsize) // some data left from previous update + { + XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize); + { + const U64* p64 = state->mem64; + state->v1 += XXH_readLE64(p64, endian) * PRIME64_2; + state->v1 = XXH_rotl64(state->v1, 31); + state->v1 *= PRIME64_1; + p64++; + state->v2 += XXH_readLE64(p64, endian) * PRIME64_2; + state->v2 = XXH_rotl64(state->v2, 31); + state->v2 *= PRIME64_1; + p64++; + state->v3 += XXH_readLE64(p64, endian) * PRIME64_2; + state->v3 = XXH_rotl64(state->v3, 31); + state->v3 *= PRIME64_1; + p64++; + state->v4 += XXH_readLE64(p64, endian) * PRIME64_2; + state->v4 = XXH_rotl64(state->v4, 31); + state->v4 *= PRIME64_1; + p64++; + } + p += 32-state->memsize; + state->memsize = 0; + } + + if (p+32 <= bEnd) + { + const BYTE* const limit = bEnd - 32; + U64 v1 = state->v1; + U64 v2 = state->v2; + U64 v3 = state->v3; + U64 v4 = state->v4; + + do + { + v1 += XXH_readLE64(p, endian) * PRIME64_2; + v1 = XXH_rotl64(v1, 31); + v1 *= PRIME64_1; + p+=8; + v2 += XXH_readLE64(p, endian) * PRIME64_2; + v2 = XXH_rotl64(v2, 31); + v2 *= PRIME64_1; + p+=8; + v3 += XXH_readLE64(p, endian) * PRIME64_2; + v3 = XXH_rotl64(v3, 31); + v3 *= PRIME64_1; + p+=8; + v4 += XXH_readLE64(p, endian) * PRIME64_2; + v4 = XXH_rotl64(v4, 31); + v4 *= PRIME64_1; + p+=8; + } + while (p<=limit); + + state->v1 = v1; + state->v2 = v2; + state->v3 = v3; + state->v4 = v4; + } + + if (p < bEnd) + { + XXH_memcpy(state->mem64, p, bEnd-p); + state->memsize = (int)(bEnd-p); + } + + return XXH_OK; +} + +XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH64_update_endian(state_in, input, len, XXH_littleEndian); + else + return XXH64_update_endian(state_in, input, len, XXH_bigEndian); +} + + + +FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state_in, XXH_endianess endian) +{ + XXH_istate64_t * state = (XXH_istate64_t *) state_in; + const BYTE * p = (const BYTE*)state->mem64; + BYTE* bEnd = (BYTE*)state->mem64 + state->memsize; + U64 h64; + + if (state->total_len >= 32) + { + U64 v1 = state->v1; + U64 v2 = state->v2; + U64 v3 = state->v3; + U64 v4 = state->v4; + + h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); + + v1 *= PRIME64_2; + v1 = XXH_rotl64(v1, 31); + v1 *= PRIME64_1; + h64 ^= v1; + h64 = h64*PRIME64_1 + PRIME64_4; + + v2 *= PRIME64_2; + v2 = XXH_rotl64(v2, 31); + v2 *= PRIME64_1; + h64 ^= v2; + h64 = h64*PRIME64_1 + PRIME64_4; + + v3 *= PRIME64_2; + v3 = XXH_rotl64(v3, 31); + v3 *= PRIME64_1; + h64 ^= v3; + h64 = h64*PRIME64_1 + PRIME64_4; + + v4 *= PRIME64_2; + v4 = XXH_rotl64(v4, 31); + v4 *= PRIME64_1; + h64 ^= v4; + h64 = h64*PRIME64_1 + PRIME64_4; + } + else + { + h64 = state->seed + PRIME64_5; + } + + h64 += (U64) state->total_len; + + while (p+8<=bEnd) + { + U64 k1 = XXH_readLE64(p, endian); + k1 *= PRIME64_2; + k1 = XXH_rotl64(k1,31); + k1 *= PRIME64_1; + h64 ^= k1; + h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; + p+=8; + } + + if (p+4<=bEnd) + { + h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1; + h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; + p+=4; + } + + while (p> 33; + h64 *= PRIME64_2; + h64 ^= h64 >> 29; + h64 *= PRIME64_3; + h64 ^= h64 >> 32; + + return h64; +} + + +unsigned long long XXH64_digest (const XXH64_state_t* state_in) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH64_digest_endian(state_in, XXH_littleEndian); + else + return XXH64_digest_endian(state_in, XXH_bigEndian); +} + diff --git a/third_party/xxhash/xxhash.h b/third_party/xxhash/xxhash.h new file mode 100644 index 0000000..1c2a3ab --- /dev/null +++ b/third_party/xxhash/xxhash.h @@ -0,0 +1,142 @@ +/* + xxHash - Extremely Fast Hash algorithm + Header File + Copyright (C) 2012-2014, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + You can contact the author at : + - xxHash source repository : http://code.google.com/p/xxhash/ +*/ + +/* Notice extracted from xxHash homepage : +xxHash is an extremely fast Hash algorithm, running at RAM speed limits. +It also successfully passes all tests from the SMHasher suite. +Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) +Name Speed Q.Score Author +xxHash 5.4 GB/s 10 +CrapWow 3.2 GB/s 2 Andrew +MumurHash 3a 2.7 GB/s 10 Austin Appleby +SpookyHash 2.0 GB/s 10 Bob Jenkins +SBox 1.4 GB/s 9 Bret Mulvey +Lookup3 1.2 GB/s 9 Bob Jenkins +SuperFastHash 1.2 GB/s 1 Paul Hsieh +CityHash64 1.05 GB/s 10 Pike & Alakuijala +FNV 0.55 GB/s 5 Fowler, Noll, Vo +CRC32 0.43 GB/s 9 +MD5-32 0.33 GB/s 10 Ronald L. Rivest +SHA1-32 0.28 GB/s 10 +Q.Score is a measure of quality of the hash function. +It depends on successfully passing SMHasher test set. +10 is a perfect score. +*/ + +#pragma once + +#if defined (__cplusplus) +extern "C" { +#endif + + +/***************************** + Includes +*****************************/ +#include /* size_t */ + + +/***************************** + Type +*****************************/ +typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; + + + +/***************************** + Simple Hash Functions +*****************************/ + +unsigned int XXH32 (const void* input, size_t length, unsigned seed); +unsigned long long XXH64 (const void* input, size_t length, unsigned long long seed); + +/* +XXH32() : + Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input". + The memory between input & input+length must be valid (allocated and read-accessible). + "seed" can be used to alter the result predictably. + This function successfully passes all SMHasher tests. + Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s +XXH64() : + Calculate the 64-bits hash of sequence of length "len" stored at memory address "input". +*/ + + + +/***************************** + Advanced Hash Functions +*****************************/ +typedef struct { long long ll[ 6]; } XXH32_state_t; +typedef struct { long long ll[11]; } XXH64_state_t; + +/* +These structures allow static allocation of XXH states. +States must then be initialized using XXHnn_reset() before first use. +If you prefer dynamic allocation, please refer to functions below. +*/ + +XXH32_state_t* XXH32_createState(void); +XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr); + +XXH64_state_t* XXH64_createState(void); +XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr); + +/* +These functions create and release memory for XXH state. +States must then be initialized using XXHnn_reset() before first use. +*/ + + +XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, unsigned seed); +XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); +unsigned int XXH32_digest (const XXH32_state_t* statePtr); + +XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, unsigned long long seed); +XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); +unsigned long long XXH64_digest (const XXH64_state_t* statePtr); + +/* +These functions calculate the xxHash of an input provided in multiple smaller packets, +as opposed to an input provided as a single block. +XXH state space must first be allocated, using either static or dynamic method provided above. +Start a new hash by initializing state with a seed, using XXHnn_reset(). +Then, feed the hash state by calling XXHnn_update() as many times as necessary. +Obviously, input must be valid, meaning allocated and read accessible. +The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. +Finally, you can produce a hash anytime, by using XXHnn_digest(). +This function returns the final nn-bits hash. +You can nonetheless continue feeding the hash state with more input, +and therefore get some new hashes, by calling again XXHnn_digest(). +When you are done, don't forget to free XXH state space, using typically XXHnn_freeState(). +*/ + + +#if defined (__cplusplus) +} +#endif